"""Rebuild the original synthetic casebook and support worksheets.

No network, provider account, wallet or blockchain is used. Labels are not valid
addresses or transaction IDs. Exact arithmetic uses integer litoshis.
"""
from pathlib import Path
from decimal import Decimal
import csv
import html
import json
import re

ROOT = Path(__file__).resolve().parent
PUBLIC_BASE = '/uploads/research/beginner-support-20261011-v1/'
REVIEW = '2026-10-11'

def write(name, value):
    (ROOT / name).write_text(value, encoding='utf-8', newline='\n')

def write_json(name, value):
    write(name, json.dumps(value, ensure_ascii=False, indent=2) + '\n')

def write_csv(name, rows):
    with (ROOT / name).open('w', encoding='utf-8', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)

def classify(c):
    # Evidence categories, not recovery verdicts. Null means unknown.
    if c['secret_exposed']:
        return 'security_exposure'
    if c['network_matches'] is False:
        return 'network_mismatch'
    if c['destination_matches'] is False:
        return 'address_mismatch'
    if not c['txid_available']:
        return 'no_network_identifier'
    if c['lookup_state'] != 'record_found':
        return 'observation_inconclusive'
    if c['confirmations'] == 0:
        return 'unconfirmed_observation'
    if c['expected_recipient_litoshis'] != c['observed_recipient_litoshis']:
        return 'amount_mismatch'
    if c['account_credited'] is False:
        return 'confirmed_credit_pending'
    return 'insufficient_evidence_for_this_casebook'

base = dict(secret_exposed=False, network_matches=True, destination_matches=True,
            txid_available=True, lookup_state='record_found', confirmations=12,
            expected_recipient_litoshis=40000000, observed_recipient_litoshis=40000000,
            account_credited=False)
cases = []
definitions = [
    ('S01', 'No transaction ID', dict(txid_available=False, lookup_state='not_checked', confirmations=None, observed_recipient_litoshis=None, destination_matches=None), 'no_network_identifier', '1', 'Sending service', 'Was the request broadcast? Provide the actual network transaction ID if it was.', 'A queued withdrawal request does not establish an on-chain payment.'),
    ('S02', 'Lookup inconclusive', dict(lookup_state='unavailable_or_unindexed', confirmations=None, observed_recipient_litoshis=None, destination_matches=None), 'observation_inconclusive', '2', 'Sending service / observation provider', 'Confirm the identifier, network and broadcast state; retain the lookup error and time.', 'An unavailable or unindexed lookup does not establish failure or cancellation.'),
    ('S03', 'Unconfirmed transaction', dict(confirmations=0), 'unconfirmed_observation', '2', 'Sending service or wallet documentation', 'What is the documented pending-transaction procedure for this payment?', 'Zero confirmations does not establish failure, cancellation or eventual inclusion.'),
    ('S04', 'Confirmed output, credit pending', dict(), 'confirmed_credit_pending', '3', 'Receiving service', 'Which stated deposit requirement or internal review remains incomplete?', 'A confirmed matching output does not establish internal account credit or ownership.'),
    ('S05', 'Recipient amount differs', dict(observed_recipient_litoshis=39800000), 'amount_mismatch', '4', 'Sending service and invoice issuer', 'Was the displayed service charge deducted? What is the underpayment procedure?', 'A recipient shortfall is not automatically a miner fee or a failed transaction.'),
    ('S06', 'Unsupported network', dict(network_matches=False, destination_matches=None, lookup_state='different_network', confirmations=None, observed_recipient_litoshis=None), 'network_mismatch', '5', 'Receiving service', 'Is there a documented recovery policy for this exact asset, network and destination?', 'This worksheet establishes no recovery capability or outcome.'),
    ('S07', 'Destination differs', dict(destination_matches=False), 'address_mismatch', '5', 'Responsible service, if known', 'Can your service identify the actual destination and state its applicable return policy?', 'An address mismatch does not establish the destination owner or a refundable payment.'),
    ('S08', 'Signing secret exposed', dict(secret_exposed=True, txid_available=False, lookup_state='not_relevant_to_security_priority', confirmations=None, observed_recipient_litoshis=None, destination_matches=None), 'security_exposure', '6', 'Official account security / trusted wallet procedure', 'Which security procedure applies? Do not send the exposed secret or backup.', 'Changing an app password does not by itself revoke exposed signing material.'),
]
for case_id, title, changes, expected, template, recipient, question, limit in definitions:
    c = dict(base)
    c.update(changes)
    c.update(case_id=case_id, title=title, expected_class=expected,
             template=template, request_to=recipient, next_question=question,
             does_not_establish=limit, fictional=True,
             transaction_label=f'FICTIONAL-{case_id}-NOT-A-TXID' if c['txid_available'] else None)
    c['computed_class'] = classify(c)
    assert c['computed_class'] == expected, case_id
    cases.append(c)

worked = dict(scope='ordinary transparent Litecoin, constructed example', fictional=True,
              input_litoshis=200000000, recipient_litoshis=40000000,
              change_litoshis=159999600, network_fee_litoshis=400,
              output_total_litoshis=199999600,
              recipient_role_provenance='assigned by fictional scenario, not explorer inference',
              transaction_label='FICTIONAL-S04-NOT-A-TXID',
              destination_label='FICTIONAL-RECIPIENT-NOT-AN-ADDRESS',
              sender_net_spent_litoshis=40000400)
assert worked['input_litoshis'] - worked['recipient_litoshis'] - worked['change_litoshis'] == worked['network_fee_litoshis']
assert worked['recipient_litoshis'] + worked['change_litoshis'] == worked['output_total_litoshis']
assert worked['input_litoshis'] - worked['change_litoshis'] == worked['sender_net_spent_litoshis']
service = dict(fictional=True, requested_litoshis=40000000, service_charge_litoshis=200000,
               deduction_rule='service charge deducted from the requested amount', delivered_litoshis=39800000,
               network_fee_claim=None, actual_provider=None)
assert service['requested_litoshis'] - service['service_charge_litoshis'] == service['delivered_litoshis']
write_json('support-cases.json', dict(version='2026-10-11-v1', evidence_type='constructed teaching casebook',
    real_provider_test=False, real_payment=False, support_response_measured=False,
    rules_note='Priority classification of fictional supplied evidence, not an automated diagnosis or recovery prediction.',
    cases=cases, worked_payment=worked, service_deduction_example=service))
write_csv('support-cases.csv', [dict(case_id=c['case_id'], title=c['title'], fictional='true',
    secret_exposed=c['secret_exposed'], network_matches=c['network_matches'], destination_matches=c['destination_matches'],
    txid_available=c['txid_available'], lookup_state=c['lookup_state'], confirmations=c['confirmations'],
    expected_recipient_litoshis=c['expected_recipient_litoshis'], observed_recipient_litoshis=c['observed_recipient_litoshis'],
    account_credited=c['account_credited'], evidence_class=c['computed_class'], template=c['template'],
    next_question=c['next_question'], does_not_establish=c['does_not_establish']) for c in cases])

header = '''LITECOIN PAYMENT SUPPORT: SIX TYPED TEMPLATES
Version 2026-10-11-v1. Original teaching resource from Litecoin.watch.
Use only inside the provider's verified support channel. Print or edit locally.
Replace brackets, keep unknown fields marked UNKNOWN, and delete irrelevant lines.
No recovery words, private key, password, 2FA code, wallet backup, descriptor or xpub.
Never publish a completed ticket: case/account/order references stay private.
Public-chain fields can link your identity to payment history.
These templates do not authenticate a provider or guarantee recovery.

'''
templates = [
('1', 'Withdrawal request without a network transaction ID', '''Subject: LTC withdrawal request - please confirm broadcast status
Asset and requested network [TEXT]:
Request date and time [ISO 8601 WITH TIMEZONE]:
Sending app and version [TEXT]:
Withdrawal request reference [PRIVATE TEXT]:
Displayed request status [EXACT TEXT]:
Requested LTC amount [DECIMAL, UP TO 8 PLACES]:
Displayed service charge and deduction rule [TEXT OR UNKNOWN]:
Actual network transaction ID: NOT PROVIDED
Question: Was this request broadcast, or is it still awaiting a service step?
If broadcast, please provide the network transaction ID and network used.
'''),
('2', 'Inconclusive lookup or visible unconfirmed transaction', '''Subject: LTC transaction observation - please confirm the next step
Asset and network [TEXT]:
Transaction ID [PUBLIC-CHAIN TEXT, PRIVATE CHANNEL]:
Sending app and version [TEXT]:
Lookup source [URL]:
Lookup time [ISO 8601 WITH TIMEZONE]:
Lookup result [EXACT TEXT: UNAVAILABLE / NOT FOUND / RECORD FOUND]:
Confirmations [INTEGER OR UNKNOWN]:
Intended destination match [YES / NO / UNKNOWN]:
Recipient output index and LTC [INTEGER + DECIMAL OR UNKNOWN]:
Withdrawal reference if needed [PRIVATE TEXT]:
Question: Please confirm identifier, network and broadcast state, and the
documented pending-transaction procedure. I have not sent a duplicate payment.
'''),
('3', 'Confirmed matching output with account credit pending', '''Subject: Confirmed LTC output - receiving account credit remains pending
Asset and network [TEXT]:
Transaction ID [PUBLIC-CHAIN TEXT, PRIVATE CHANNEL]:
Relevant output index [NONNEGATIVE INTEGER]:
Relevant full destination [PUBLIC-CHAIN TEXT, PRIVATE CHANNEL]:
Recipient amount LTC [DECIMAL, UP TO 8 PLACES]:
Source and lookup time [URL + ISO 8601 WITH TIMEZONE]:
Active-chain confirmations at that lookup [INTEGER]:
Receiving instructions saved at [ISO 8601 WITH TIMEZONE]:
Destination compared against saved instructions [YES / NO / UNKNOWN]:
Current minimum and confirmation requirement [SOURCE + TEXT OR UNKNOWN]:
Receiving account status and check time [PRIVATE TEXT + TIME]:
Order/deposit reference required for this case [PRIVATE TEXT OR OMIT]:
Question: Which stated deposit requirement or internal review remains incomplete?
Please identify the next required action through this authenticated case.
'''),
('4', 'Invoice amount and delivered output differ', '''Subject: LTC invoice shortfall - request for reconciliation rule
Invoice reference [PRIVATE TEXT]:
Required amount LTC [DECIMAL, UP TO 8 PLACES]:
Invoice address and validity period [PRIVATE CONTEXT + PUBLIC-CHAIN TEXT]:
Transaction ID and relevant output index [PUBLIC-CHAIN TEXT + INTEGER]:
Delivered recipient amount LTC [DECIMAL, UP TO 8 PLACES]:
Source and lookup time [URL + ISO 8601 WITH TIMEZONE]:
Gross withdrawal request LTC [DECIMAL OR UNKNOWN]:
Displayed service charge LTC and deduction rule [DECIMAL + TEXT OR UNKNOWN]:
Network fee LTC [DECIMAL OR UNKNOWN; SEPARATE FROM SERVICE CHARGE]:
Question: Which amount did your system credit, and what is the accepted
underpayment, top-up or refund procedure? I have not reused an expired invoice.
'''),
('5', 'Wrong network or different destination', '''Subject: Asset/network/destination mismatch - request for documented policy
Sending asset and actual network [EXACT TEXT]:
Requested receiving asset and network [EXACT TEXT]:
Actual transaction ID on the actual network [PUBLIC-CHAIN TEXT OR UNKNOWN]:
Actual destination [PUBLIC-CHAIN TEXT, PRIVATE CHANNEL]:
Destination in saved receiving instructions [PUBLIC-CHAIN TEXT, PRIVATE CHANNEL]:
Recipient output amount if visible [DECIMAL OR UNKNOWN]:
Instruction and observation times [ISO 8601 WITH TIMEZONE]:
Relevant private request/invoice reference [PRIVATE TEXT OR OMIT]:
Mismatch [NETWORK / ADDRESS / BOTH / UNKNOWN]:
Question: Does your service control the relevant destination or offer a
documented procedure for this exact asset and network? Please state the
eligibility, limits and applicable charges. I understand recovery is not assured.
Do not supply any seed, key, wallet file or signing material with this message.
'''),
('6', 'Security exposure, without disclosing the secret again', '''Subject: Security incident - request for official account procedure
Product involved [CUSTODIAL ACCOUNT / SELF-CUSTODY WALLET / UNKNOWN]:
Approximate incident time [ISO 8601 WITH TIMEZONE]:
Incident category [CREDENTIAL DISCLOSURE / SIGNING-MATERIAL DISCLOSURE /
REMOTE ACCESS / SUSPICIOUS MESSAGE / UNKNOWN]:
Actions already taken through official controls [TEXT, NO SECRETS]:
Verified case reference if one already exists [PRIVATE TEXT OR OMIT]:
Question: Which official security procedure applies to this product?
This ticket contains no disclosed secret and no wallet backup or descriptor.
For self-custody exposure, I understand that support cannot revoke a private
key and that securing funds may require new uncompromised signing material.
'''),
]
combined = header
for number, title, body in templates:
    value = f'TEMPLATE {number}: {title}\n\n{body}'
    write(f'template-{number}.txt', header + value)
    combined += value + '\n' + '-' * 68 + '\n\n'
write('support-ticket-templates.txt', combined)

blank = '''LITECOIN PAYMENT RECEIPT: PRIVATE WORKING SHEET
Version 2026-10-11-v1. Ordinary transparent Litecoin only.
Print or edit locally. Send selected fields only through verified support.
Do not enter recovery words, private keys, passwords, 2FA codes, backup files,
wallet descriptors or extended public keys. This is not a wallet recovery form.

PUBLIC-CHAIN FIELDS (still private when linked to your identity)
Asset and actual network:
Actual transaction ID (UNKNOWN if not provided):
Relevant output index:
Relevant full destination (not an assumed change/refund address):
Recipient output LTC, maximum 8 decimal places:
Input total LTC, only if complete:
Output total LTC, only if complete:
Calculated network fee LTC, only if complete:
Confirmations as observed:
Block hash/height if needed:
Observation source URL:
Observation time with timezone:

PRIVATE ACCOUNT / INVOICE CONTEXT (do not post publicly)
Sending service/app and version:
Sending request status as displayed:
Private request reference (only if needed):
Invoice/deposit reference (only if needed):
Saved receiving instructions: source, time, asset and network:
Does relevant full output destination match instructions? YES / NO / UNKNOWN
Required invoice LTC:
Gross withdrawal request LTC:
Displayed service charge, unit and deduction rule:
Receiving confirmation/minimum policy, source and check time:
Receiver status as displayed and check time:
Specific unresolved question:
Verified support channel and case reference:

ATTACHMENT CHECK
[ ] Only the fields required for this case are selected.
[ ] No wallet/recovery material, passwords or authentication codes.
[ ] No unrelated balances, account identity, notifications or QR codes.
[ ] Any image was exported as a new flattened copy and that file inspected.
[ ] Cropping and metadata handling were not assumed to guarantee redaction.
[ ] Later observations are dated separately; unknown facts remain UNKNOWN.

An explorer is an observer, not proof of address ownership or account credit.
An API outage or not-found lookup does not establish failure. No recovery promise.
'''
write('receipt-evidence-blank.txt', blank)
write('receipt-evidence-fictional.txt', '''COMPLETED FICTIONAL RECEIPT EVIDENCE SHEET
Every value, label, time and confirmation count below is constructed.
No actual payment, provider ticket or response-time measurement occurred.
Labels are deliberately not usable Litecoin addresses or transaction IDs.

Case: S04 - confirmed matching output; internal account credit pending.
Asset/network: native Litecoin / ordinary transparent Litecoin mainnet scope.
Transaction label: FICTIONAL-S04-NOT-A-TXID
Recipient label: FICTIONAL-RECIPIENT-NOT-AN-ADDRESS
Output index: 0
Recipient amount: 0.40000000 LTC / 40,000,000 litoshis
Input total: 2.00000000 LTC / 200,000,000 litoshis
Other output, assigned change by this scenario: 1.59999600 LTC
Output total: 1.99999600 LTC
Network fee: 0.00000400 LTC / 400 litoshis
Sender net spent after assigned change: 0.40000400 LTC
Fictional confirmations: 12
Observation label: CONSTRUCTED OBSERVER, NOT A LIVE EXPLORER
Fictional observation time: 2026-10-11T12:00:00Z
Full destination comparison: MATCH, assigned in scenario.
Receiver account status: PENDING, assigned in scenario.
Private account/order reference: OMITTED
Required policy threshold: UNKNOWN; retrieve receiver's applicable policy.
Question: Which stated deposit requirement or internal review is still incomplete?

Arithmetic: 200000000 - 40000000 - 159999600 = 400 litoshis.
This worksheet does not prove owner identity or promise an account credit.
''')

privacy = [
('app_version','general_technical','usually_shareable','include','Avoid unrelated device identifiers'),
('error_text','general_technical','redact_identifiers','include_relevant_error','Error text can contain names, paths or tokens'),
('asset_and_network','general_technical','usually_shareable','include','Use the actual network, not a ticker assumption'),
('txid','public_chain','omit_by_default','include_if_needed','Can link identity with chain history'),
('output_index','public_chain','omit_by_default','include_with_txid','One exact output, not total outputs'),
('recipient_address','public_chain','omit_by_default','include_if_needed','Do not infer ownership from label'),
('output_amount','public_chain','omit_by_default','include_if_needed','Amount attached to identity is privacy context'),
('confirmation_snapshot','public_chain','redact_payment_linkage','include_source_and_time','Not an account-credit verdict'),
('account_or_email','private_account','redact','only_if_verified_case_requires','No public account fields in templates'),
('invoice_or_request_reference','private_account','redact','only_if_needed','Keep case mapping inside authenticated channel'),
('invoice_and_withdrawal_policy','private_account_context','redact_customer_context','relevant_fields_only','Separate quoted service charges from chain fee'),
('recovery_phrase','secret_never_collect','never','never','Can authorize spending'),
('private_key','secret_never_collect','never','never','Can authorize spending'),
('password_or_2fa','secret_never_collect','never','never','Not ticket evidence'),
('raw_wallet_backup','potential_signing_secret_never_collect','never','never_for_this_payment_sheet','May contain signing and identity material'),
('descriptor_or_xpub','wallet_scope_sensitive_never_collect_here','never','never_for_this_payment_sheet','Can expose wallet-wide history; descriptor may contain private keys'),
]
write_csv('field-privacy.csv', [dict(field=a, classification=b, public_post=c, authenticated_support=d, reason=e) for a,b,c,d,e in privacy])
write_json('worked-payment.json', worked)

sources = [
('coinbase-impersonation','Coinbase','Technical support and impersonation scams','https://help.coinbase.com/en/coinbase/privacy-and-security/avoid-scams/tech-support-scams','Official support does not ask for a seed phrase, password, 2FA code, software installation or remote access; authenticated contact routes.'),
('coinbase-account-security','Coinbase','Make your account more secure','https://help.coinbase.com/en/coinbase/privacy-and-security/data-privacy/how-can-i-make-my-account-more-secure','Use official app/bookmark/help center; fake support sites and numbers; account security controls.'),
('coinbase-recovery-phrase','Coinbase','Coinbase wallet recovery phrase','https://help.coinbase.com/en-au/wallet/managing-account/wallet-recovery-phrase','Never share recovery phrase; provider cannot use it to move a self-custody wallet balance. Product-specific support may change.'),
('kraken-wallet-secret','Kraken','Create a wallet on Kraken Wallet','https://support.kraken.com/articles/create-a-wallet-on-kraken-wallet','Do not disclose secret recovery phrase to someone claiming to be Kraken Support. This is security guidance, not a recommendation of a Litecoin-compatible wallet.'),
('kraken-missing-deposit','Kraken','Cryptocurrency deposit is missing','https://support.kraken.com/articles/360001488126-cryptocurrency-deposit-is-missing','Receiving checks include network, amount, confirmation policy, address and maintenance; MWEB-specific limitation reinforces scope. Provider-specific policy.'),
('kraken-deposit-instructions','Kraken','How to deposit cryptocurrencies to your Kraken account','https://support.kraken.com/articles/360000672643-how-to-deposit-cryptocurrencies-to-your-kraken-account','Use the current deposit instructions and supported network; requirements are specific to the currency and service.'),
('coinbase-troubleshooting','Coinbase','Send and receive troubleshooting','https://help.coinbase.com/en/coinbase/trading-and-funding/cryptocurrency-trading-pairs/send-and-receive-troubleshooting','Check sender status, destination, network, and receiving account alerts. Provider timing not generalized in this guide.'),
('bitcoin-privacy','Bitcoin.org','Protect your privacy','https://bitcoin.org/en/protect-your-privacy','Public addresses and transaction history can be linked to identity; applied by analogy to ordinary transparent Litecoin, not MWEB.'),
('bitcoin-transactions','Bitcoin developer documentation','Transactions','https://developer.bitcoin.org/devguide/transactions.html#transaction-fees-and-change','Shared UTXO and change structure. Historical fee recommendations in this page were not adopted.'),
('litecoin-input-validation','Litecoin Core','CheckTxInputs in Core v0.21.5.8','https://github.com/litecoin-project/litecoin/blob/v0.21.5.8/src/consensus/tx_verify.cpp','For ordinary transparent transactions, input sum minus output value provides network fee; MWEB-specific code excluded from teaching example.'),
('litecoin-output-structure','Litecoin Core','Transaction output structure in Core v0.21.5.8','https://github.com/litecoin-project/litecoin/blob/v0.21.5.8/src/primitives/transaction.h','Transparent output stores value and script separately; not personal account identity or service credit. MWEB separate.'),
]
write_json('sources.json', dict(review_date=REVIEW, review_type='author source review, not independent audit',
    primary_sources=[dict(id=a, publisher=b, title=c, url=d, reviewed_on=REVIEW, supports=e) for a,b,c,d,e in sources],
    original_material=dict(type='synthetic casebook and support worksheets', mainnet_test=False, provider_test=False,
        source_file='generate-assets.py.txt', calculation_units='integer litoshis', no_secret_collection=True),
    internal_links=[dict(url='/learn/missing-payment/',verified='live source reviewed'),
                    dict(url='/articles/how-to-read-a-litecoin-block-explorer-transactions-addresses-and-blocks',verified='live source reviewed'),
                    dict(url='/articles/we-changed-a-litecoin-wallet-password-the-old-backup-could-still-spend',verified='public URL checked by publisher on 2026-10-11')]))
write('README.txt', '''LITECOIN PAYMENT SUPPORT CASEBOOK AND WORKSHEETS
Version: 2026-10-11-v1. Source review: 11 October 2026.
Author/responsible editor: Jarosław Wasiński.

Original contribution
Eight constructed evidence states select six different support request templates.
Each case records both the useful next question and the conclusion its evidence
does not establish. The worksheet separates public-chain records, private account
context and material that must never be collected for payment support.

These are fictional teaching cases. No exchange, wallet application or support
team was tested. No transaction was broadcast, no funds used, no account accessed,
and no support response time measured. The stated times and confirmation counts
in the sample are invented for demonstration. Labels are not valid live IDs or
addresses. The examples are not observations or population statistics.

Reproduction
Run Python 3 generate-assets.py.txt in this folder. It regenerates the CSV/JSON,
templates, worksheets, metadata and this README using no network access. It
asserts the eight classifications and payment arithmetic in integer litoshis.
Those assertions verify teaching material only, not provider behavior.
Use a different case only after explicitly defining its evidence and unknowns.
Classification is a priority organization of supplied fields, not a diagnostic
system or statement of legal ownership, suitability or recovery eligibility.

Worked transparent payment
200,000,000 input litoshis = 40,000,000 recipient + 159,999,600 assigned change
+ 400 network-fee litoshis. The recipient amount is not input or output total.
The independent service-charge example deducts 200,000 litoshis from a 40,000,000
litoshi request, delivering 39,800,000. It claims no corresponding network fee.
Change ownership is given by the example; an explorer label would not prove it.

Scope and privacy
Ordinary transparent Litecoin. No reconstruction of private MWEB outputs,
wrapped-asset diagnosis, wrong-network recovery guarantee or real account credit
verification. Explorer lookups are third-party observations. No seeds, private
keys, passwords, 2FA, raw backups, descriptors or xpubs belong in these templates.
The blank sheet is a private working document: disclose selected relevant fields
to authenticated support only. Public-chain fields can still reveal identity.

Source review
sources.json records primary official pages reviewed for the article. Providers'
rules are current guidance for their own products, not universal Litecoin rules.
Bitcoin transaction documentation is used for shared structure; its historical
fee advice is not current Litecoin policy. Core source is pinned v0.21.5.8.
No archived HTML capture hash or independent reviewer is claimed.

Publication assets
support-cases.csv, support-cases.json, worked-payment.json,
field-privacy.csv, support-ticket-templates.txt and template-1.txt to template-6.txt,
receipt-evidence-blank.txt, receipt-evidence-fictional.txt, sources.json,
generate-assets.py.txt and README.txt. The accompanying article is published separately.
Intended public download base: /uploads/research/beginner-support-20261011-v1/
Research and drafting used AI assistance; no independent external review claimed.
''')
write_json('validation.json', dict(case_count=len(cases), matched_classifications=8,
    templates=len(templates), transparent_payment_balances=True, service_deduction_balances=True,
    real_provider_test=False, real_network_test=False))
print(json.dumps(dict(cases=len(cases), templates=len(templates), arithmetic='passed')))