Publish exact v1.1.4 mirror inventory

.gitattributes

@@ -7,3 +7,4 @@
 *.txt text eol=lf
 *.yaml text eol=lf
 *.yml text eol=lf
+lifted-payments-statement-audit-model-v1.1.4.zip filter=lfs diff=lfs merge=lfs -text

.zenodo.json

@@ -1,39 +0,0 @@
-{
-  "title": "Lifted Payments Payment Statement Audit Model",
-  "upload_type": "dataset",
-  "description": "<p>A processor-neutral, machine-readable model for normalizing monthly merchant payment-processing statements without storing cardholder data. Version 1.1.3 preserves the schema 1.1.0 contract and v1.1.2 validator rules while adding clean committed-tree provenance, authoritative remote-tag and monotonic-version checks, pre-execution static gates, and bounded non-executing attestation of GitHub, Zenodo, DOI, Hugging Face, and Software Heritage identities and bytes.</p>",
-  "creators": [
-    {
-      "name": "Lifted Payments",
-      "affiliation": "Lifted Holdings"
-    }
-  ],
-  "version": "1.1.3",
-  "publication_date": "2026-08-02",
-  "access_right": "open",
-  "license": "cc-by-4.0",
-  "language": "eng",
-  "keywords": [
-    "payment processing",
-    "merchant services",
-    "effective rate",
-    "statement audit",
-    "fintech",
-    "JSON Schema",
-    "payments data",
-    "cost analysis"
-  ],
-  "related_identifiers": [
-    {
-      "identifier": "https://liftedpayments.com/payment-processing-statement-audit/",
-      "relation": "isDocumentedBy",
-      "resource_type": "publication-technicalnote"
-    },
-    {
-      "identifier": "https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3",
-      "relation": "isSourceOf",
-      "resource_type": "software"
-    }
-  ],
-  "notes": "All figures and validation vectors are synthetic and do not describe a real merchant. The model contains no cardholder data. The validation report records 2 accepted valid vectors and 14 correctly rejected invalid vectors. Package 1.1.3 preserves the schema 1.1.0 record contract. The publication gate proves declared package and release provenance; it is not an accounting opinion, legal review, interchange-pricing guarantee, or malware sandbox."
-}

CHANGELOG.md

@@ -1,39 +0,0 @@
-# Changelog
-
-All notable changes to the versioned dataset package are recorded here. Published release artifacts remain immutable.
-
-## 1.1.3 - 2026-08-02
-
-- Split portable package validation from publication readiness so a tagless archive can never claim release provenance.
-- Require a clean committed tree, authoritative origin, complete remote tag inventory, exact local/remote tag alignment, and monotonic new versions.
-- Run static inventory, path, size, encoding, checksum, credential-signature, identity, and provenance checks before executing candidate Python.
-- Add a bounded non-executing public attestor for GitHub release assets, Zenodo metadata and bytes, DOI resolution, Hugging Face archive equality, and Software Heritage branch/tag provenance.
-- Reject unsafe redirects, oversized responses, archive traversal, case-fold aliases, symlinks, undeclared members, digest mismatches, and public identity drift.
-- Add 20 provenance and external-attestation regressions while preserving the schema 1.1.0 record contract.
-
-## 1.1.2 - 2026-08-02
-
-- Require the publication gate to compare the manifest with the complete candidate release tree.
-- Run the candidate validator's behavioral regression suite in addition to the compact synthetic corpus.
-- Bound release file count, individual asset size, and aggregate release size before content scanning.
-- Reject spreadsheet-formula prefixes in CSV cells without echoing submitted values.
-- Validate trusted title, semantic versions, release date, DOI pair, license, canonical URL, and source-release identity.
-- Block changed files from masquerading as an existing immutable Git tag.
-- Add regression coverage for identity, bank, credential, rounding-tie, and zero-fee edge cases.
-
-## 1.1.1 - 2026-08-02
-
-Security and release-engineering patch; the record contract remains schema version 1.1.0.
-
-- Reject pathological JSON number magnitudes and exponents before Decimal arithmetic.
-- Return stable, value-free errors for unreadable inputs and hostile direct numeric values.
-- Execute the candidate release's own corpus validator in a bounded child process.
-- Block malformed manifests, path traversal, missing critical assets, stale reports, and candidate-validator failures.
-- Scan every declared release asset for common credential signatures.
-- Add an adversarial extreme-number vector and public security/threat-model documentation.
-
-## 1.1.0 - 2026-08-02
-
-- Defined gross settled purchase volume and net processing fees as the calculation basis.
-- Added exact fee-group, credit, effective-rate, and average-ticket reconciliation.
-- Added the semantic validator, adversarial corpus, pinned runtime, checksums, and fail-closed publication gate.

CITATION.cff

@@ -1,18 +0,0 @@
-cff-version: 1.2.0
-message: "If you use this audit model, cite it using the metadata below."
-title: "Lifted Payments Payment Statement Audit Model"
-type: dataset
-authors:
-  - name: "Lifted Payments"
-version: 1.1.3
-date-released: 2026-08-02
-doi: "10.5281/zenodo.21764642"
-url: "https://liftedpayments.com/payment-processing-statement-audit/"
-repository-code: "https://github.com/Lifted-Holdings/payment-processing-resources"
-license: CC-BY-4.0
-keywords:
-  - payment processing
-  - merchant services
-  - effective rate
-  - statement audit
-  - fintech

DATA_DICTIONARY.md

@@ -1,41 +0,0 @@
-# Payment statement audit data dictionary
-
-This dictionary defines v1.1.0 of the Lifted Payments Payment Statement Audit Model. Words such as “volume,” “fees,” and “transactions” are ambiguous across provider statements; the definitions below are part of the contract, not suggestions.
-
-## Record-level fields
-
-| Field | Type | Required | Definition |
-|---|---:|:---:|---|
-| `schema_version` | string | yes | Literal `1.1.0`. A different value requires a different schema and validator. |
-| `calculation_basis` | string | yes | Literal `gross_settled_purchase_volume_and_net_processing_fees`. It prevents unlike numerator and denominator conventions from being compared silently. |
-| `statement_period.start` | ISO date | yes | First calendar date represented by the statement, inclusive. |
-| `statement_period.end` | ISO date | yes | Last calendar date represented by the statement, inclusive. It must be on or after `start`; the inclusive period may not exceed 62 days. |
-| `currency` | string | yes | Literal `USD`. Do not convert or combine other currencies in a v1.1.0 record. |
-| `card_volume` | USD | yes | Gross dollar amount of settled purchase transactions in the period. Include the full settled purchase amount, including tax and tip when those are part of the capture. Exclude declines, authorization-only events, voids, refunds, chargebacks, cash advances, reserves, and funding adjustments. |
-| `transaction_count` | integer | yes | Number of settled purchase transactions included in `card_volume`. Exclude declines, authorization-only events, voids, refunds, and chargebacks. Volume and count must both be zero or both be positive. |
-| `gross_processing_fees` | USD | yes | Sum of the nine `fee_groups` before processing-fee credits. It includes only fees for accepting, authorizing, settling, supporting, or administering card processing. |
-| `statement_credits` | USD | yes | Processing-fee credits or rebates applied on the statement. Exclude customer refunds, chargeback principal, reserve releases, deposit adjustments, and other movement of merchant funds. |
-| `total_processing_fees` | USD | yes | Net fee numerator: `gross_processing_fees - statement_credits`. It cannot be negative in v1.1.0. |
-| `effective_rate` | decimal or null | yes | `total_processing_fees / card_volume`, rounded half up to six decimal places. Store `2.2918%` as `0.022918`. It must be `null` when `card_volume` is zero. |
-| `average_ticket` | USD or null | yes | `card_volume / transaction_count`, rounded half up to cents. It must be `null` when `transaction_count` is zero. |
-| `pricing_model` | enum | yes | How pricing is presented on the source statement: `interchange_plus`, `flat_rate`, `tiered`, `subscription`, `dual_pricing`, or `unknown`. This is not an interchange-qualification opinion. |
-| `fee_groups` | array | yes | One entry per used category. Categories are unique, amounts are gross nonnegative charges, and their exact cent sum equals `gross_processing_fees`. For a zero-activity, zero-fee statement, use one `other` entry with amount `0.00` because schema v1.1.0 requires at least one group. |
-| `review_notes` | string array | no | Short explanations of classification decisions. Never put merchant identity, card/account data, credentials, or secrets here. |
-
-All USD fields permit at most two decimal places. Rates permit at most six decimal places. Numbers must be finite. The validator imposes high operational ceilings to reject account-number-shaped or clearly implausible input; those ceilings are data-safety bounds, not merchant eligibility limits.
-
-## Fee-group taxonomy
-
-| Category | Include | Exclude or redirect |
-|---|---|---|
-| `interchange` | Issuer/interchange charges presented by the statement | Network assessments and provider markup |
-| `assessments` | Card-network assessment, access, and brand charges | Interchange and processor markup |
-| `processor_markup` | Provider percentage, basis-point, per-item, or service markup not assigned elsewhere | Pass-through interchange and assessments |
-| `authorization` | Authorization, gateway, capture, AVS, and similar per-attempt service fees | Settled-item markup already classified in `processor_markup` |
-| `monthly` | Monthly account, statement, minimum, batch, or platform administration fees | Equipment service and PCI program fees when separately stated |
-| `pci` | PCI program, non-validation, or compliance-service fees | Penalties unrelated to processing, which belong in `other` with a note |
-| `equipment` | Terminal rental, device service, replacement plan, or connectivity fees charged on the processing statement | Equipment sale principal, financing, or lease obligations outside processing cost |
-| `chargebacks` | Chargeback, retrieval, arbitration, and dispute administration fees | Chargeback transaction principal or lost sale amount |
-| `other` | A processing-related fee that fits no category, with a concise classification note | Refund principal, reserves, taxes withheld, loans/advances, financing principal, or merchant deposits |
-
-Never omit a fee to make a rate look better. If the source statement does not provide enough information to classify a processing-related charge, put it in `other` and document the reason. If the statement mixes periods or currencies and they cannot be separated faithfully, do not publish a v1.1.0 record.

LICENSE.md

@@ -1,395 +0,0 @@
-Attribution 4.0 International
-
-=======================================================================
-
-Creative Commons Corporation ("Creative Commons") is not a law firm and
-does not provide legal services or legal advice. Distribution of
-Creative Commons public licenses does not create a lawyer-client or
-other relationship. Creative Commons makes its licenses and related
-information available on an "as-is" basis. Creative Commons gives no
-warranties regarding its licenses, any material licensed under their
-terms and conditions, or any related information. Creative Commons
-disclaims all liability for damages resulting from their use to the
-fullest extent possible.
-
-Using Creative Commons Public Licenses
-
-Creative Commons public licenses provide a standard set of terms and
-conditions that creators and other rights holders may use to share
-original works of authorship and other material subject to copyright
-and certain other rights specified in the public license below. The
-following considerations are for informational purposes only, are not
-exhaustive, and do not form part of our licenses.
-
-     Considerations for licensors: Our public licenses are
-     intended for use by those authorized to give the public
-     permission to use material in ways otherwise restricted by
-     copyright and certain other rights. Our licenses are
-     irrevocable. Licensors should read and understand the terms
-     and conditions of the license they choose before applying it.
-     Licensors should also secure all rights necessary before
-     applying our licenses so that the public can reuse the
-     material as expected. Licensors should clearly mark any
-     material not subject to the license. This includes other CC-
-     licensed material, or material used under an exception or
-     limitation to copyright. More considerations for licensors:
-     wiki.creativecommons.org/Considerations_for_licensors
-
-     Considerations for the public: By using one of our public
-     licenses, a licensor grants the public permission to use the
-     licensed material under specified terms and conditions. If
-     the licensor's permission is not necessary for any reason--for
-     example, because of any applicable exception or limitation to
-     copyright--then that use is not regulated by the license. Our
-     licenses grant only permissions under copyright and certain
-     other rights that a licensor has authority to grant. Use of
-     the licensed material may still be restricted for other
-     reasons, including because others have copyright or other
-     rights in the material. A licensor may make special requests,
-     such as asking that all changes be marked or described.
-     Although not required by our licenses, you are encouraged to
-     respect those requests where reasonable. More considerations
-     for the public:
-     wiki.creativecommons.org/Considerations_for_licensees
-
-=======================================================================
-
-Creative Commons Attribution 4.0 International Public License
-
-By exercising the Licensed Rights (defined below), You accept and agree
-to be bound by the terms and conditions of this Creative Commons
-Attribution 4.0 International Public License ("Public License"). To the
-extent this Public License may be interpreted as a contract, You are
-granted the Licensed Rights in consideration of Your acceptance of
-these terms and conditions, and the Licensor grants You such rights in
-consideration of benefits the Licensor receives from making the
-Licensed Material available under these terms and conditions.
-
-
-Section 1 -- Definitions.
-
-  a. Adapted Material means material subject to Copyright and Similar
-     Rights that is derived from or based upon the Licensed Material
-     and in which the Licensed Material is translated, altered,
-     arranged, transformed, or otherwise modified in a manner requiring
-     permission under the Copyright and Similar Rights held by the
-     Licensor. For purposes of this Public License, where the Licensed
-     Material is a musical work, performance, or sound recording,
-     Adapted Material is always produced where the Licensed Material is
-     synched in timed relation with a moving image.
-
-  b. Adapter's License means the license You apply to Your Copyright
-     and Similar Rights in Your contributions to Adapted Material in
-     accordance with the terms and conditions of this Public License.
-
-  c. Copyright and Similar Rights means copyright and/or similar rights
-     closely related to copyright including, without limitation,
-     performance, broadcast, sound recording, and Sui Generis Database
-     Rights, without regard to how the rights are labeled or
-     categorized. For purposes of this Public License, the rights
-     specified in Section 2(b)(1)-(2) are not Copyright and Similar
-     Rights.
-
-  d. Effective Technological Measures means those measures that, in the
-     absence of proper authority, may not be circumvented under laws
-     fulfilling obligations under Article 11 of the WIPO Copyright
-     Treaty adopted on December 20, 1996, and/or similar international
-     agreements.
-
-  e. Exceptions and Limitations means fair use, fair dealing, and/or
-     any other exception or limitation to Copyright and Similar Rights
-     that applies to Your use of the Licensed Material.
-
-  f. Licensed Material means the artistic or literary work, database,
-     or other material to which the Licensor applied this Public
-     License.
-
-  g. Licensed Rights means the rights granted to You subject to the
-     terms and conditions of this Public License, which are limited to
-     all Copyright and Similar Rights that apply to Your use of the
-     Licensed Material and that the Licensor has authority to license.
-
-  h. Licensor means the individual(s) or entity(ies) granting rights
-     under this Public License.
-
-  i. Share means to provide material to the public by any means or
-     process that requires permission under the Licensed Rights, such
-     as reproduction, public display, public performance, distribution,
-     dissemination, communication, or importation, and to make material
-     available to the public including in ways that members of the
-     public may access the material from a place and at a time
-     individually chosen by them.
-
-  j. Sui Generis Database Rights means rights other than copyright
-     resulting from Directive 96/9/EC of the European Parliament and of
-     the Council of 11 March 1996 on the legal protection of databases,
-     as amended and/or succeeded, as well as other essentially
-     equivalent rights anywhere in the world.
-
-  k. You means the individual or entity exercising the Licensed Rights
-     under this Public License. Your has a corresponding meaning.
-
-
-Section 2 -- Scope.
-
-  a. License grant.
-
-       1. Subject to the terms and conditions of this Public License,
-          the Licensor hereby grants You a worldwide, royalty-free,
-          non-sublicensable, non-exclusive, irrevocable license to
-          exercise the Licensed Rights in the Licensed Material to:
-
-            a. reproduce and Share the Licensed Material, in whole or
-               in part; and
-
-            b. produce, reproduce, and Share Adapted Material.
-
-       2. Exceptions and Limitations. For the avoidance of doubt, where
-          Exceptions and Limitations apply to Your use, this Public
-          License does not apply, and You do not need to comply with
-          its terms and conditions.
-
-       3. Term. The term of this Public License is specified in Section
-          6(a).
-
-       4. Media and formats; technical modifications allowed. The
-          Licensor authorizes You to exercise the Licensed Rights in
-          all media and formats whether now known or hereafter created,
-          and to make technical modifications necessary to do so. The
-          Licensor waives and/or agrees not to assert any right or
-          authority to forbid You from making technical modifications
-          necessary to exercise the Licensed Rights, including
-          technical modifications necessary to circumvent Effective
-          Technological Measures. For purposes of this Public License,
-          simply making modifications authorized by this Section 2(a)
-          (4) never produces Adapted Material.
-
-       5. Downstream recipients.
-
-            a. Offer from the Licensor -- Licensed Material. Every
-               recipient of the Licensed Material automatically
-               receives an offer from the Licensor to exercise the
-               Licensed Rights under the terms and conditions of this
-               Public License.
-
-            b. No downstream restrictions. You may not offer or impose
-               any additional or different terms or conditions on, or
-               apply any Effective Technological Measures to, the
-               Licensed Material if doing so restricts exercise of the
-               Licensed Rights by any recipient of the Licensed
-               Material.
-
-       6. No endorsement. Nothing in this Public License constitutes or
-          may be construed as permission to assert or imply that You
-          are, or that Your use of the Licensed Material is, connected
-          with, or sponsored, endorsed, or granted official status by,
-          the Licensor or others designated to receive attribution as
-          provided in Section 3(a)(1)(A)(i).
-
-  b. Other rights.
-
-       1. Moral rights, such as the right of integrity, are not
-          licensed under this Public License, nor are publicity,
-          privacy, and/or other similar personality rights; however, to
-          the extent possible, the Licensor waives and/or agrees not to
-          assert any such rights held by the Licensor to the limited
-          extent necessary to allow You to exercise the Licensed
-          Rights, but not otherwise.
-
-       2. Patent and trademark rights are not licensed under this
-          Public License.
-
-       3. To the extent possible, the Licensor waives any right to
-          collect royalties from You for the exercise of the Licensed
-          Rights, whether directly or through a collecting society
-          under any voluntary or waivable statutory or compulsory
-          licensing scheme. In all other cases the Licensor expressly
-          reserves any right to collect such royalties.
-
-
-Section 3 -- License Conditions.
-
-Your exercise of the Licensed Rights is expressly made subject to the
-following conditions.
-
-  a. Attribution.
-
-       1. If You Share the Licensed Material (including in modified
-          form), You must:
-
-            a. retain the following if it is supplied by the Licensor
-               with the Licensed Material:
-
-                 i. identification of the creator(s) of the Licensed
-                    Material and any others designated to receive
-                    attribution, in any reasonable manner requested by
-                    the Licensor (including by pseudonym if
-                    designated);
-
-                ii. a copyright notice;
-
-               iii. a notice that refers to this Public License;
-
-                iv. a notice that refers to the disclaimer of
-                    warranties;
-
-                 v. a URI or hyperlink to the Licensed Material to the
-                    extent reasonably practicable;
-
-            b. indicate if You modified the Licensed Material and
-               retain an indication of any previous modifications; and
-
-            c. indicate the Licensed Material is licensed under this
-               Public License, and include the text of, or the URI or
-               hyperlink to, this Public License.
-
-       2. You may satisfy the conditions in Section 3(a)(1) in any
-          reasonable manner based on the medium, means, and context in
-          which You Share the Licensed Material. For example, it may be
-          reasonable to satisfy the conditions by providing a URI or
-          hyperlink to a resource that includes the required
-          information.
-
-       3. If requested by the Licensor, You must remove any of the
-          information required by Section 3(a)(1)(A) to the extent
-          reasonably practicable.
-
-       4. If You Share Adapted Material You produce, the Adapter's
-          License You apply must not prevent recipients of the Adapted
-          Material from complying with this Public License.
-
-
-Section 4 -- Sui Generis Database Rights.
-
-Where the Licensed Rights include Sui Generis Database Rights that
-apply to Your use of the Licensed Material:
-
-  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
-     to extract, reuse, reproduce, and Share all or a substantial
-     portion of the contents of the database;
-
-  b. if You include all or a substantial portion of the database
-     contents in a database in which You have Sui Generis Database
-     Rights, then the database in which You have Sui Generis Database
-     Rights (but not its individual contents) is Adapted Material; and
-
-  c. You must comply with the conditions in Section 3(a) if You Share
-     all or a substantial portion of the contents of the database.
-
-For the avoidance of doubt, this Section 4 supplements and does not
-replace Your obligations under this Public License where the Licensed
-Rights include other Copyright and Similar Rights.
-
-
-Section 5 -- Disclaimer of Warranties and Limitation of Liability.
-
-  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
-     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
-     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
-     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
-     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
-     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
-     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
-     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
-     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
-     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
-
-  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
-     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
-     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
-     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
-     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
-     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
-     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
-     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
-     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
-
-  c. The disclaimer of warranties and limitation of liability provided
-     above shall be interpreted in a manner that, to the extent
-     possible, most closely approximates an absolute disclaimer and
-     waiver of all liability.
-
-
-Section 6 -- Term and Termination.
-
-  a. This Public License applies for the term of the Copyright and
-     Similar Rights licensed here. However, if You fail to comply with
-     this Public License, then Your rights under this Public License
-     terminate automatically.
-
-  b. Where Your right to use the Licensed Material has terminated under
-     Section 6(a), it reinstates:
-
-       1. automatically as of the date the violation is cured, provided
-          it is cured within 30 days of Your discovery of the
-          violation; or
-
-       2. upon express reinstatement by the Licensor.
-
-     For the avoidance of doubt, this Section 6(b) does not affect any
-     right the Licensor may have to seek remedies for Your violations
-     of this Public License.
-
-  c. For the avoidance of doubt, the Licensor may also offer the
-     Licensed Material under separate terms or conditions or stop
-     distributing the Licensed Material at any time; however, doing so
-     will not terminate this Public License.
-
-  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
-     License.
-
-
-Section 7 -- Other Terms and Conditions.
-
-  a. The Licensor shall not be bound by any additional or different
-     terms or conditions communicated by You unless expressly agreed.
-
-  b. Any arrangements, understandings, or agreements regarding the
-     Licensed Material not stated herein are separate from and
-     independent of the terms and conditions of this Public License.
-
-
-Section 8 -- Interpretation.
-
-  a. For the avoidance of doubt, this Public License does not, and
-     shall not be interpreted to, reduce, limit, restrict, or impose
-     conditions on any use of the Licensed Material that could lawfully
-     be made without permission under this Public License.
-
-  b. To the extent possible, if any provision of this Public License is
-     deemed unenforceable, it shall be automatically reformed to the
-     minimum extent necessary to make it enforceable. If the provision
-     cannot be reformed, it shall be severed from this Public License
-     without affecting the enforceability of the remaining terms and
-     conditions.
-
-  c. No term or condition of this Public License will be waived and no
-     failure to comply consented to unless expressly agreed to by the
-     Licensor.
-
-  d. Nothing in this Public License constitutes or may be interpreted
-     as a limitation upon, or waiver of, any privileges and immunities
-     that apply to the Licensor or You, including from the legal
-     processes of any jurisdiction or authority.
-
-
-=======================================================================
-
-Creative Commons is not a party to its public licenses.
-Notwithstanding, Creative Commons may elect to apply one of its public
-licenses to material it publishes and in those instances will be
-considered the “Licensor.” The text of the Creative Commons public
-licenses is dedicated to the public domain under the CC0 Public Domain
-Dedication. Except for the limited purpose of indicating that material
-is shared under a Creative Commons public license or as otherwise
-permitted by the Creative Commons policies published at
-creativecommons.org/policies, Creative Commons does not authorize the
-use of the trademark "Creative Commons" or any other trademark or logo
-of Creative Commons without its prior written consent including,
-without limitation, in connection with any unauthorized modifications
-to any of its public licenses or any other arrangements,
-understandings, or agreements concerning use of licensed material. For
-the avoidance of doubt, this paragraph does not form part of the public
-licenses.
-
-Creative Commons may be contacted at creativecommons.org.

METHODOLOGY.md

@@ -1,50 +0,0 @@
-# Statement audit methodology and limitations
-
-## Purpose
-
-The Lifted Payments Payment Statement Audit Model normalizes one processing statement into comparable monthly totals. It is designed for reproducible arithmetic, fee-taxonomy review, and month-over-month or provider-to-provider comparison. It is not a substitute for the original statement, merchant agreement, card-brand rules, tax advice, legal advice, an accounting opinion, or an interchange-qualification analysis.
-
-## Procedure
-
-1. Confirm that the source covers one USD statement period of no more than 62 inclusive days. If the statement combines currencies or inseparable periods, stop.
-2. Record gross settled purchase volume and its matching settled purchase count. Do not use net deposits, net sales after refunds, authorization volume, or funding totals.
-3. Identify every processing-related charge for the same period. Exclude transaction principal, refund and chargeback principal, reserves, withholding, loan or advance repayment, and equipment financing principal.
-4. Assign each gross charge exactly once to the taxonomy in [`DATA_DICTIONARY.md`](./DATA_DICTIONARY.md). Put ambiguous processing charges in `other` with a note; do not drop them.
-5. Sum the fee groups to `gross_processing_fees`. Record only processing-fee rebates or credits in `statement_credits`. Subtract those credits to obtain `total_processing_fees`.
-6. Compute the effective rate from net processing fees and gross settled purchase volume. Compute average ticket from that same volume and count. Use decimal arithmetic and round half up only at the published precision.
-7. Run the companion validator. Correct the source mapping—not the validator result—when a rule fails. Preserve the source statement privately according to the merchant’s controls; never attach it to this public resource.
-
-## Equations
-
-```text
-gross_processing_fees = exact sum(fee_groups.amount)
-total_processing_fees = gross_processing_fees - statement_credits
-effective_rate = round_half_up(total_processing_fees / card_volume, 6)
-average_ticket = round_half_up(card_volume / transaction_count, 2)
-```
-
-When volume and count are zero, `effective_rate` and `average_ticket` are `null`. Fixed monthly fees may still make `total_processing_fees` positive. A percentage shown to people is `effective_rate × 100`; the JSON value remains a decimal.
-
-If a zero-activity statement also has zero processing fees, retain one explicit `other` fee group with amount `0.00`; schema v1.1.0 requires one fee-group entry and this convention avoids inventing a positive charge. CSV text cells beginning with `=`, `+`, `-`, or `@` (after leading whitespace) are rejected because spreadsheet software may interpret them as formulas.
-
-## What the effective rate can and cannot show
-
-The rate is an all-in normalization of the included statement costs. It can support consistent comparisons when records use the same basis. It does not isolate provider margin, prove that interchange was qualified correctly, predict a future bill, or guarantee savings. Card mix, ticket size, acceptance channel, rewards mix, disputes, seasonality, statement timing, and fee changes can move the rate without a pricing change.
-
-Comparisons should use multiple representative statements when available and should present absolute dollars, volume, transaction count, fee groups, and rate together. A single rate without its basis and period is not a complete audit.
-
-## Validation architecture
-
-The JSON Schema enforces types, required fields, enums, bounds, and unknown-field rejection. The Python validator additionally enables date-format assertion, parses JSON numbers as `Decimal`, rejects duplicate keys and non-finite values, and enforces cross-field accounting rules. This split is intentional: Draft 2020-12 `format` is annotation by default, and JSON Schema does not express date ordering or arithmetic equality across fields.
-
-Validation errors expose only rule code, JSON Pointer path, and a fixed message. They do not echo submitted values. The shipped corpus contains valid and deliberately invalid synthetic vectors so independent users can reproduce both acceptance and rejection behavior.
-
-## Privacy and security boundary
-
-This model needs statement-level aggregates only. It has no fields for PAN, truncated PAN, cardholder name, expiration date, track data, security codes, PIN/PIN block, bank account or routing numbers, tax or government identifiers, merchant owner data, credentials, tokens, or secrets. Unknown fields are rejected. Notes are scanned for Luhn-valid PAN-like sequences, labeled authentication/bank data, email addresses, and common credential patterns.
-
-Automated screening reduces accidental disclosure; it cannot prove that arbitrary prose contains no personal or confidential information. A human must review any record before public release. Never use this repository or a public dataset mirror to upload a real merchant statement or a record containing merchant-identifying information.
-
-## Corrections and versioning
-
-Published version artifacts and their checksums are immutable. A calculation or contract change receives a new semantic version, GitHub release, and Zenodo version DOI linked by the concept DOI. Metadata-only corrections that do not change released files may be amended at the archive, but the repository documents the correction. Known limitations are disclosed rather than silently “fixed” in prior versions.

README.md

@@ -9,30 +9,25 @@ tags:
 - payments
 - merchant-services
 - effective-rate
-configs:
-- config_name: default
-  data_files:
-  - split: examples
-    path: examples/payment-statement-audit-example.json
 ---
 
 # Lifted Payments Payment Statement Audit Model
 
 A processor-neutral data contract for turning monthly merchant payment-processing totals into a consistent, comparable audit record. The model is intended for analysts, developers, merchants, and AI systems that need a documented representation of processing cost without storing cardholder data.
 
-This distribution contains package version **1.1.3** and its schema **1.1.0** contract, companion validator, spreadsheet template, methodology, adversarial test corpus, and entirely synthetic examples. It is a reusable specification and demonstration package, not a collection of real merchant statements.
+This distribution contains package version **1.1.4** and its schema **1.1.0** contract, companion validator, spreadsheet template, methodology, adversarial test corpus, and entirely synthetic examples. It is a reusable specification and demonstration package, not a collection of real merchant statements. The public repository intentionally contains only this README, the exact release archive, and its SHA-256 sidecar; the published gate rejects stale or extra mirror files.
 
 ## Persistent identity
 
 - Canonical methodology: https://liftedpayments.com/payment-processing-statement-audit/
-- Version DOI: https://doi.org/10.5281/zenodo.21764642
+- Version DOI: https://doi.org/10.5281/zenodo.21765280
 - Concept DOI: https://doi.org/10.5281/zenodo.21761714
-- Versioned source release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3
+- Versioned source release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.4
 - Source repository: https://github.com/Lifted-Holdings/payment-processing-resources
 
 ## Files
 
-| File | Role |
+| Path inside the release archive | Role |
 |---|---|
 | `payment-statement-audit-template.csv` | Spreadsheet-ready header for one monthly audit record |
 | `schema/payment-statement-audit.schema.json` | JSON Schema Draft 2020-12 validation contract |
@@ -44,6 +39,8 @@ This distribution contains package version **1.1.3** and its schema **1.1.0** co
 | `codemeta.json` | Schema.org and CodeMeta dataset identity |
 | `checksums.txt` | SHA-256 integrity values for the portable data files |
 
+The mirror-level `release-archive.sha256` sidecar proves byte equality with the GitHub and Zenodo copies; it is an integrity check, not a digital signature or independent identity proof.
+
 ## Core fields
 
 | Field | Meaning |
@@ -83,7 +80,7 @@ The included example is synthetic and describes no real merchant. Never add card
 
 ## Citation
 
-> Lifted Payments. (2026). *Lifted Payments Payment Statement Audit Model* (Version 1.1.3). Zenodo. https://doi.org/10.5281/zenodo.21764642
+> Lifted Payments. (2026). *Lifted Payments Payment Statement Audit Model* (Version 1.1.4). Zenodo. https://doi.org/10.5281/zenodo.21765280
 
 ## License
 

RELEASE-MANIFEST.json

@@ -1,61 +0,0 @@
-{
-  "title": "Lifted Payments Payment Statement Audit Model",
-  "version": "1.1.3",
-  "schema_version": "1.1.0",
-  "release_date": "2026-08-02",
-  "version_doi": "10.5281/zenodo.21764642",
-  "concept_doi": "10.5281/zenodo.21761714",
-  "canonical_url": "https://liftedpayments.com/payment-processing-statement-audit/",
-  "source_release": "https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3",
-  "license": "CC-BY-4.0",
-  "files": [
-    ".gitattributes",
-    ".zenodo.json",
-    "CHANGELOG.md",
-    "CITATION.cff",
-    "checksums.txt",
-    "codemeta.json",
-    "DATA_DICTIONARY.md",
-    "distribution/huggingface/README.md",
-    "distribution/kaggle/dataset-metadata.json",
-    "distribution/kaggle/README.md",
-    "examples/payment-statement-audit-example.json",
-    "LICENSE.md",
-    "llms.txt",
-    "METHODOLOGY.md",
-    "payment-statement-audit-template.csv",
-    "README.md",
-    "RELEASE-MANIFEST.json",
-    "requirements-validation.txt",
-    "schema/payment-statement-audit.schema.json",
-    "SECURITY.md",
-    "test-vectors/invalid/activity-mismatch.json",
-    "test-vectors/invalid/duplicate-category.json",
-    "test-vectors/invalid/fee-sum-mismatch.json",
-    "test-vectors/invalid/fractional-cent.json",
-    "test-vectors/invalid/invalid-date.json",
-    "test-vectors/invalid/net-fee-mismatch.json",
-    "test-vectors/invalid/overlong-period.json",
-    "test-vectors/invalid/overprecise-rate.json",
-    "test-vectors/invalid/pathological-number.json",
-    "test-vectors/invalid/security-data-in-note.json",
-    "test-vectors/invalid/reversed-period.json",
-    "test-vectors/invalid/unknown-field.json",
-    "test-vectors/invalid/wrong-average-ticket.json",
-    "test-vectors/invalid/wrong-effective-rate.json",
-    "test-vectors/manifest.json",
-    "test-vectors/valid/standard-month.json",
-    "test-vectors/valid/zero-activity-month.json",
-    "tests/test_audit_validator.py",
-    "tests/test_public_release_attestation.py",
-    "tests/test_publication_gate.py",
-    "tests/test_release_assets.py",
-    "tests/test_release_provenance.py",
-    "tools/public_release_attestation.py",
-    "tools/publication_gate.py",
-    "tools/release_provenance.py",
-    "tools/update_checksums.py",
-    "tools/validate_audit.py",
-    "validation-report.json"
-  ]
-}

SECURITY.md

@@ -1,44 +0,0 @@
-# Security policy and publication threat model
-
-## Supported release
-
-Security fixes are applied to the newest versioned release. Published GitHub and Zenodo artifacts are immutable; a fix receives a new release, checksums, validation report, and Zenodo version DOI.
-
-## What the publication gate defends
-
-The release gate is designed to fail closed when it encounters:
-
-- a malformed, incomplete, duplicated, absolute, or path-traversing manifest;
-- an undeclared file in the candidate release tree;
-- a missing, symlinked, non-UTF-8, or non-LF declared artifact;
-- an excessive file count, individual asset size, or aggregate release size;
-- a checksum mismatch or undeclared security-critical file;
-- a validator that fails, times out, emits malformed output, or does not reproduce the corpus;
-- a candidate validator that fails its bounded behavioral regression suite;
-- an unpinned validation dependency or stale validation report;
-- inconsistent package, schema, citation, DOI, or source-release identity;
-- a candidate that reuses an existing release version while changing its tagged files;
-- a tagless archive or incomplete clone presented as publication-ready;
-- a dirty or uncommitted candidate tree;
-- an origin outside the authoritative Lifted Holdings repository;
-- an unavailable, malformed, missing, divergent, or non-monotonic remote release tag;
-- common private-key, cloud-key, repository-token, model-token, chat-token, or live payment-key signatures anywhere in the declared release; or
-- synthetic records that violate structural, accounting, precision, period, privacy, size, depth, safe-number, or spreadsheet-formula rules.
-
-Candidate validation runs in a bounded child process and must return a machine-readable corpus report. Gate output contains fixed rule messages and hashes, never released file contents or submitted statement values.
-
-## Assurance modes and execution order
-
-`--mode package` is portable and proves internal consistency only. Its successful status is `valid`, never `ready` or `verified`. `--mode candidate` is the publication boundary and requires a real clean Git worktree, committed byte identity, the authoritative origin, and a complete remote tag inventory. `--mode published` additionally verifies public release and archive evidence; a network, rate-limit, redirect, digest, or identity failure blocks rather than falling back to local success.
-
-The gate performs bounded manifest, path, inventory, size, encoding, checksum, secret-signature, identity, Git, and tag checks before it executes the candidate validator or its behavioral regression suite. This prevents an untrusted or incomplete candidate from reaching the executable portion of the workflow merely because it can rewrite its own checksum file.
-
-## Trust boundaries and non-goals
-
-This repository accepts only statement-level aggregates. It is not designed to ingest source statements, cardholder data, bank data, merchant-owner data, credentials, or secrets. Automated pattern screening is defense in depth; it cannot prove arbitrary prose contains no identifying or confidential information. Human review remains mandatory before any record is made public.
-
-The gate establishes reproducibility, internal consistency, and declared release provenance. It is not a malware sandbox, digital signature, accounting opinion, legal determination, interchange-qualification audit, or guarantee that a mapped source statement is complete. Run executable candidate validation only on a locally reviewed checkout. Published mode verifies release identity and bytes; it does not make arbitrary contributed Python safe to execute.
-
-## Reporting a vulnerability
-
-Use GitHub's private vulnerability reporting workflow in the repository Security tab. Do not include real merchant statements, PANs, authentication data, bank details, credentials, or other sensitive values in a report. A minimal synthetic reproducer is sufficient.

checksums.txt

@@ -1,47 +0,0 @@
-04ad658cdb6c353e0dc5370b6046cbb109cd32e70f855f3109e6d0b58f643fe9 .gitattributes
-67e5ff8fcd780d06d5af0eea9e45446867acc7b59fad6fa804c75854d25a66bb .zenodo.json
-7b4ec6231e50037e6768151e00c11bc0afc28af3dea6bd42719c41204093ab11 CHANGELOG.md
-200160f0fe93775f2d46ba22d359789a86b3d73ec0826e5d6ebc20a18dcc3784 CITATION.cff
-042fc2859745c561aac599568148651d52fa5723c61643fc6fd7cf4a7e9eac37 DATA_DICTIONARY.md
-f5b745ef98087f531e719ee8ca6a96809444573ecc7173c6fa68eaad39b3cc3f LICENSE.md
-e5fb71de92248b8867c8fd0f0f93e93aa4a3e5d2c968f0d5c95cc106f46f5489 METHODOLOGY.md
-478c5db4ba9479afb78a55ff1021ecb538f05d1ba85d29172390f9e442168c4b README.md
-dd7656da1e7d1a3a189c3f8bc37855beebbb2d55c42299d93a1f4f615c39e8ec RELEASE-MANIFEST.json
-c0a99f8575f303bf54c8be9331e67ed28d74751982ff894148ffdf20240818de SECURITY.md
-86be15179f7237bdf99bcfee7402dfc3930e30112d90004f4dc4c37353417baf codemeta.json
-a97106304eef9d19e46743f7d302235fd7686566f76edb1082b786798ed949d5 distribution/huggingface/README.md
-10f83fee3320bc731090b9bf6e582d8e6c6764414ff06ae0a8e8d1a9b57c8f62 distribution/kaggle/README.md
-c5b24adf34e28e11aafa4975dbe37b653481346e3c228e1e844f45f04de46f53 distribution/kaggle/dataset-metadata.json
-7a3299b4490d0e7f0c1a99a48859bce9742f632d8796699d80a48221e9fa38af examples/payment-statement-audit-example.json
-2c8d4aad2ca52c2bd0014f1d7d3915e3eefb7d4dab02ae7fe33313673c725782 llms.txt
-51cde2dd0d9da13e47c50228f96f8cc624662b5edcccb3f95719f53a79a1a47c payment-statement-audit-template.csv
-d53f1737b5cb16cd8ad3c79ae4082ff35b0f120eb45bd502a042b3e5f275ac1f requirements-validation.txt
-5979ec9c587be20ae723879f3863edb1f5a78ccddc848ca9a183b58532271730 schema/payment-statement-audit.schema.json
-3bad5c0b256a0a65640515c00d6e1eea316039f57e3ec08a6809eee4c75f176a test-vectors/invalid/activity-mismatch.json
-2ee2c9552d3728bcddce248cf3a3b8c12ec06c5923f48412688e544c69cdb78a test-vectors/invalid/duplicate-category.json
-57f100181eb71060b16d3ae9e1861ef1eb79940f0bf7f4f1e618a97bb1e4415d test-vectors/invalid/fee-sum-mismatch.json
-dd522dff07da399c5fc46d2d02a4cb9109c7f1860ec58a4849392e9aff853f52 test-vectors/invalid/fractional-cent.json
-23c4e68b176b807df6738a4b0a9a8adbddbf9ddaee26d0b4262a6905652af951 test-vectors/invalid/invalid-date.json
-0ef3f62501948cd15f7d69b4b64f43c78cb110f9937f5a2115e2e7e7f85eb0c7 test-vectors/invalid/net-fee-mismatch.json
-caeb952d6e2c93597b6f7def52616e7b390c8f8807b9740a4ae6acb6ecba1d30 test-vectors/invalid/overlong-period.json
-fb401b20ccfa0b3278948e60dbc7efc9e6c140d9facc7a58ddceb09ebfa32029 test-vectors/invalid/overprecise-rate.json
-3733785277878384a097291b3dfbc4342ce0859cee2a73db8633e83ea2f730a6 test-vectors/invalid/pathological-number.json
-96aa4e395b6fb9154673602441429aaf3cb3cb962899f3f9b355b4cfb0fb6d17 test-vectors/invalid/reversed-period.json
-5a1821ccd329b53e393dd27d6eca8c4da7ed09f9963d36efe7eb2bfe7f47c0d9 test-vectors/invalid/security-data-in-note.json
-a102b3b69c9260579982d5d668a57ab5494d1baba89fe8d93cd1b5ef5d564572 test-vectors/invalid/unknown-field.json
-8520c8dc0244c121e85e39ae63af1846e15acf902355afa0ce515838c6160b7b test-vectors/invalid/wrong-average-ticket.json
-b185d1eb11f805c1dac0e0a5aa69be8bb35fbed1079673a3e8a2abba45d83a36 test-vectors/invalid/wrong-effective-rate.json
-7cf60eb7353825a9d21199f45860539590fb59a5c8964bd264e507b431d794f5 test-vectors/manifest.json
-d73ed747b481e60c3c4502a1738997f04a6a5c63ceb1268ebd4e4fb8e3e0baea test-vectors/valid/standard-month.json
-9a0f4872a6b588d246954727deb02bc5b7e82bac9921efb5ebf1e0b27a558a10 test-vectors/valid/zero-activity-month.json
-c2ec930b5fed0fd75f239c72ad51d334ff6c003c1416a8191b21d80e84656ce3 tests/test_audit_validator.py
-9aa1785145954aa93d345465827d577bfb7d92bf23ef357e5611b2d68eaa0aed tests/test_public_release_attestation.py
-180a1d1d0a71a7167537e481b7746f6f5d4266bdb23029985141e329bde225ae tests/test_publication_gate.py
-81d5d589cba17d88cae25c6994fbd35b509a599e50f3f7b7834b514e35681e2d tests/test_release_assets.py
-8e286558ebebedac83adb98cd598ea671d28963316b2ef645de0ff5ce23e8728 tests/test_release_provenance.py
-33e08a4723f556d04f0d83120c1bf628f89f5e711fb5735a66e3cad5b51dba00 tools/public_release_attestation.py
-4440277885f5ada1beea10553732fe2f74f66e14c31eb1d2a2c71e34121cae98 tools/publication_gate.py
-63068e495cd58f969b35cdfe67fb2810eff846482ec79a3edc6ca5be423ca4fb tools/release_provenance.py
-9efff7ec3bfff067abaaf8a5d2c5008c3aaf0bf7b25c49ff623c37552de6bb10 tools/update_checksums.py
-0fede54b398f6f58d7152592f47991855724b0af8d260e5a8bce000fb05be4cc tools/validate_audit.py
-d5b203a020a9c1345322ba1445f80bd6ca777240562e891833cab7b3e776b794 validation-report.json

codemeta.json

@@ -1,39 +0,0 @@
-{
-  "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
-  "@type": "Dataset",
-  "name": "Lifted Payments Payment Statement Audit Model",
-  "description": "A processor-neutral, validated model for normalizing monthly merchant payment-processing statements without cardholder data.",
-  "version": "1.1.3",
-  "datePublished": "2026-08-02",
-  "license": "https://creativecommons.org/licenses/by/4.0/",
-  "identifier": "https://doi.org/10.5281/zenodo.21764642",
-  "url": "https://liftedpayments.com/payment-processing-statement-audit/",
-  "sameAs": [
-    "https://doi.org/10.5281/zenodo.21764642",
-    "https://doi.org/10.5281/zenodo.21761714",
-    "https://zenodo.org/records/21764642"
-  ],
-  "codeRepository": "https://github.com/Lifted-Holdings/payment-processing-resources",
-  "creator": {
-    "@type": "Organization",
-    "name": "Lifted Payments",
-    "url": "https://liftedpayments.com/"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "Lifted Holdings",
-    "url": "https://liftedholdings.com/"
-  },
-  "keywords": [
-    "payment processing",
-    "merchant services",
-    "effective rate",
-    "statement audit",
-    "fintech",
-    "JSON Schema",
-    "payments data",
-    "cost analysis"
-  ],
-  "isAccessibleForFree": true,
-  "inLanguage": "en"
-}

distribution/huggingface/README.md

@@ -1,90 +0,0 @@
----
-license: cc-by-4.0
-language:
-- en
-pretty_name: "Lifted Payments Payment Statement Audit Model"
-tags:
-- tabular
-- finance
-- payments
-- merchant-services
-- effective-rate
-configs:
-- config_name: default
-  data_files:
-  - split: examples
-    path: examples/payment-statement-audit-example.json
----
-
-# Lifted Payments Payment Statement Audit Model
-
-A processor-neutral data contract for turning monthly merchant payment-processing totals into a consistent, comparable audit record. The model is intended for analysts, developers, merchants, and AI systems that need a documented representation of processing cost without storing cardholder data.
-
-This distribution contains package version **1.1.3** and its schema **1.1.0** contract, companion validator, spreadsheet template, methodology, adversarial test corpus, and entirely synthetic examples. It is a reusable specification and demonstration package, not a collection of real merchant statements.
-
-## Persistent identity
-
-- Canonical methodology: https://liftedpayments.com/payment-processing-statement-audit/
-- Version DOI: https://doi.org/10.5281/zenodo.21764642
-- Concept DOI: https://doi.org/10.5281/zenodo.21761714
-- Versioned source release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3
-- Source repository: https://github.com/Lifted-Holdings/payment-processing-resources
-
-## Files
-
-| File | Role |
-|---|---|
-| `payment-statement-audit-template.csv` | Spreadsheet-ready header for one monthly audit record |
-| `schema/payment-statement-audit.schema.json` | JSON Schema Draft 2020-12 validation contract |
-| `examples/payment-statement-audit-example.json` | Complete synthetic example record |
-| `DATA_DICTIONARY.md` and `METHODOLOGY.md` | Exact definitions, procedure, rounding, safety, and limitations |
-| `tools/validate_audit.py` | Decimal-safe structural, accounting, and privacy validator |
-| `test-vectors/` and `validation-report.json` | Reproducible acceptance/rejection corpus and result |
-| `CITATION.cff` | Citation metadata |
-| `codemeta.json` | Schema.org and CodeMeta dataset identity |
-| `checksums.txt` | SHA-256 integrity values for the portable data files |
-
-## Core fields
-
-| Field | Meaning |
-|---|---|
-| `statement_period` | Start and end dates covered by the monthly statement |
-| `card_volume` | Total card sales volume for the same period |
-| `transaction_count` | Count of processed transactions |
-| `gross_processing_fees` | Exact sum of gross fee-group charges |
-| `statement_credits` | Processing-fee credits or rebates, reported separately |
-| `total_processing_fees` | Gross fees minus statement credits |
-| `effective_rate` | Net processing fees divided by gross settled purchase volume, stored as a decimal |
-| `pricing_model` | The pricing structure observed in the statement |
-| `fee_groups` | Fees grouped into stable comparison categories |
-| `review_notes` | Analyst notes, assumptions, and data-quality boundaries |
-
-The core calculation is:
-
-```text
-effective rate = net processing fees / gross settled purchase volume
-```
-
-For example, `0.022918` displays as `2.2918%` after multiplying by 100 for presentation.
-
-## Intended uses
-
-- Normalize statement totals before comparing months or proposals.
-- Validate an audit record against a stable machine-readable schema.
-- Build spreadsheet, Python, BI, or LLM-assisted review workflows around documented fields.
-- Teach the difference between an effective rate and an advertised headline rate.
-- Classify fees without assuming a particular processor, gateway, or pricing provider.
-
-## Limitations and safety
-
-The model does not determine legal compliance, tax treatment, network qualification, underwriting eligibility, accounting correctness, or future pricing. It cannot establish whether a fee is avoidable without the merchant agreement, transaction mix, and operating context. Automated privacy screening reduces accidental disclosure but cannot prove arbitrary notes contain no confidential information; a human review remains required before public release.
-
-The included example is synthetic and describes no real merchant. Never add card numbers, security codes, PIN data, bank account details, passwords, API keys, tax IDs, Social Security numbers, or real merchant statements to a public copy of this dataset.
-
-## Citation
-
-> Lifted Payments. (2026). *Lifted Payments Payment Statement Audit Model* (Version 1.1.3). Zenodo. https://doi.org/10.5281/zenodo.21764642
-
-## License
-
-Released under [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0/). Attribution is required when the model or its documentation is reused.

distribution/kaggle/README.md

@@ -1,34 +0,0 @@
-# Lifted Payments Payment Statement Audit Model
-
-This is the Kaggle distribution of package version **1.1.3** and schema **1.1.0** of the Lifted Payments Payment Statement Audit Model: a processor-neutral CSV template, JSON Schema, companion validator, methodology, adversarial test corpus, and synthetic examples for normalizing monthly merchant payment-processing costs.
-
-## Authoritative references
-
-- Canonical methodology: https://liftedpayments.com/payment-processing-statement-audit/
-- Version DOI: https://doi.org/10.5281/zenodo.21764642
-- Concept DOI: https://doi.org/10.5281/zenodo.21761714
-- Versioned source release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3
-- Source repository: https://github.com/Lifted-Holdings/payment-processing-resources
-
-## What the files do
-
-- `payment-statement-audit-template.csv` supplies a spreadsheet-ready field header.
-- `payment-statement-audit.schema.json` validates structured audit records.
-- `payment-statement-audit-example.json` demonstrates a complete record using synthetic values.
-- `DATA_DICTIONARY.md` and `METHODOLOGY.md` define every calculation, inclusion, exclusion, rounding rule, and limitation.
-- `validate_audit.py`, the synthetic test vectors, and `validation-report.json` make acceptance and rejection behavior reproducible.
-- `CITATION.cff`, `codemeta.json`, and `checksums.txt` preserve citation, entity identity, and file integrity.
-
-Fee groups reconcile exactly to gross processing fees; processing-fee credits are separate. The effective rate is calculated as net processing fees divided by gross settled purchase volume. The JSON value is stored as a decimal and multiplied by 100 only for percentage display.
-
-## Safety and limits
-
-The example is synthetic and describes no real merchant. This package contains no cardholder data and must never be extended with real statements, card numbers, security codes, bank details, passwords, API keys, tax IDs, or owner Social Security numbers.
-
-The model supports consistent analysis; it does not determine legal compliance, tax treatment, network qualification, underwriting eligibility, or guaranteed savings.
-
-## Citation and license
-
-> Lifted Payments. (2026). *Lifted Payments Payment Statement Audit Model* (Version 1.1.3). Zenodo. https://doi.org/10.5281/zenodo.21764642
-
-Licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

distribution/kaggle/dataset-metadata.json

@@ -1,42 +0,0 @@
-{
-  "title": "Lifted Payments Payment Statement Audit Model",
-  "subtitle": "A processor-neutral schema and synthetic merchant statement audit example",
-  "description": "Package 1.1.3 of the Lifted Payments processor-neutral model for normalizing monthly merchant payment-processing statement totals, preserving the schema 1.1.0 record contract. The package contains a CSV template, JSON Schema Draft 2020-12 contract, Decimal-safe companion validator, methodology, synthetic adversarial vectors, reproducible validation report, citation metadata, and SHA-256 checksums. Canonical methodology: https://liftedpayments.com/payment-processing-statement-audit/ . Version DOI: https://doi.org/10.5281/zenodo.21764642 . No real merchant or cardholder data is included.",
-  "id": "liftedpayments/payment-statement-audit-model",
-  "licenses": [
-    {
-      "name": "CC-BY-4.0"
-    }
-  ],
-  "resources": [
-    {
-      "path": "payment-statement-audit-template.csv",
-      "description": "Spreadsheet-ready header for one monthly payment statement audit record."
-    },
-    {
-      "path": "payment-statement-audit.schema.json",
-      "description": "JSON Schema Draft 2020-12 validation contract for audit records."
-    },
-    {
-      "path": "payment-statement-audit-example.json",
-      "description": "Complete synthetic example with no real merchant or cardholder data."
-    },
-    {
-      "path": "CITATION.cff",
-      "description": "Citation metadata for package version 1.1.3."
-    },
-    {
-      "path": "codemeta.json",
-      "description": "Schema.org and CodeMeta dataset identity."
-    },
-    {
-      "path": "checksums.txt",
-      "description": "SHA-256 integrity values for the portable source files."
-    }
-  ],
-  "keywords": [
-    "finance",
-    "business",
-    "data analysis"
-  ]
-}

examples/payment-statement-audit-example.json

@@ -1,26 +0,0 @@
-{
-  "schema_version": "1.1.0",
-  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
-  "statement_period": { "start": "2026-06-01", "end": "2026-06-30" },
-  "currency": "USD",
-  "card_volume": 125000.00,
-  "transaction_count": 1860,
-  "gross_processing_fees": 2864.75,
-  "statement_credits": 0.00,
-  "total_processing_fees": 2864.75,
-  "effective_rate": 0.022918,
-  "average_ticket": 67.20,
-  "pricing_model": "interchange_plus",
-  "fee_groups": [
-    { "category": "interchange", "amount": 1849.25, "notes": "Illustrative network interchange total." },
-    { "category": "assessments", "amount": 171.50, "notes": "Illustrative network assessments." },
-    { "category": "processor_markup", "amount": 575.00, "notes": "Illustrative percentage and per-item markup." },
-    { "category": "authorization", "amount": 186.00, "notes": "Illustrative authorization fees." },
-    { "category": "monthly", "amount": 49.00, "notes": "Illustrative account and statement fees." },
-    { "category": "pci", "amount": 34.00, "notes": "Illustrative compliance-program fee." }
-  ],
-  "review_notes": [
-    "All figures are synthetic and do not describe a real merchant.",
-    "Fee groups reconcile to gross processing fees; processing-fee credits are reported separately."
-  ]
-}

lifted-payments-statement-audit-model-v1.1.4.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b92c00b9f0a5a36fcdd5c005f30cb4037de0c39e89ab9c32c229dfc71ffd801c
+size 287396

llms.txt

@@ -1,26 +0,0 @@
-# Lifted Payments open resources
-
-This public repository contains a processor-neutral payment processing statement audit model from Lifted Payments.
-
-Canonical guide: https://liftedpayments.com/payment-processing-statement-audit/
-Version DOI: https://doi.org/10.5281/zenodo.21764642
-Concept DOI: https://doi.org/10.5281/zenodo.21761714
-Versioned release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3
-Organization: https://liftedpayments.com/
-Merchant application: https://liftedholdings.com/apply
-License: CC BY 4.0
-
-Files:
-- payment-statement-audit-template.csv: spreadsheet-ready monthly statement summary.
-- schema/payment-statement-audit.schema.json: JSON Schema Draft 2020-12 data contract.
-- examples/payment-statement-audit-example.json: synthetic example; no real merchant or cardholder data.
-- DATA_DICTIONARY.md: exact field, inclusion, exclusion, and fee-category definitions.
-- METHODOLOGY.md: reproducible calculation, rounding, privacy, and limitation rules.
-- tools/validate_audit.py: structural, accounting, and privacy validator using decimal arithmetic.
-- validation-report.json: reproducible result for 2 valid and 14 invalid synthetic vectors.
-- SECURITY.md: publication threat model, trust boundaries, and private reporting path.
-- CITATION.cff: citation metadata.
-
-Package 1.1.3 validates schema 1.1.0 records using gross settled purchase volume and net processing fees. Gross fee groups reconcile exactly; processing-fee credits are separate. Effective rate equals net processing fees divided by gross settled purchase volume, rounded half up to six decimal places. Store it as a decimal and multiply by 100 only for percentage display.
-
-Never add card numbers, bank details, credentials, tax IDs, owner Social Security numbers, or real merchant statements to this public repository.

payment-statement-audit-template.csv

@@ -1,2 +0,0 @@
-schema_version,calculation_basis,statement_start,statement_end,currency,card_volume,transaction_count,gross_processing_fees,statement_credits,total_processing_fees,effective_rate,average_ticket,pricing_model,interchange,assessments,processor_markup,authorization,monthly,pci,equipment,chargebacks,other,notes
-1.1.0,gross_settled_purchase_volume_and_net_processing_fees,2026-06-01,2026-06-30,USD,125000.00,1860,2864.75,0.00,2864.75,0.022918,67.20,interchange_plus,1849.25,171.50,575.00,186.00,49.00,34.00,0.00,0.00,0.00,Synthetic example only; replace every value with figures from your own statement

release-archive.sha256

@@ -1 +1 @@
-b1d398ada2bb456de0fffc5278b68a48554ffd5d80232d654416102ad87d5897  lifted-payments-statement-audit-model-v1.1.3.zip
+b92c00b9f0a5a36fcdd5c005f30cb4037de0c39e89ab9c32c229dfc71ffd801c  lifted-payments-statement-audit-model-v1.1.4.zip

requirements-validation.txt

@@ -1,5 +0,0 @@
-attrs==26.1.0
-jsonschema==4.26.0
-jsonschema-specifications==2025.9.1
-referencing==0.37.0
-rpds-py==2026.6.3

schema/payment-statement-audit.schema.json

@@ -1,155 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://liftedpayments.com/assets/data/payment-statement-audit.schema.json",
-  "title": "Lifted Payments Payment Statement Audit Model",
-  "description": "A processor-neutral contract for normalizing statement-level merchant processing totals without cardholder or bank-account data. Cross-field accounting and privacy rules are enforced by tools/validate_audit.py.",
-  "type": "object",
-  "required": [
-    "schema_version",
-    "calculation_basis",
-    "statement_period",
-    "currency",
-    "card_volume",
-    "transaction_count",
-    "gross_processing_fees",
-    "statement_credits",
-    "total_processing_fees",
-    "effective_rate",
-    "average_ticket",
-    "pricing_model",
-    "fee_groups"
-  ],
-  "properties": {
-    "schema_version": {
-      "const": "1.1.0",
-      "description": "Version of this data contract."
-    },
-    "calculation_basis": {
-      "const": "gross_settled_purchase_volume_and_net_processing_fees",
-      "description": "Declares the numerator and denominator convention used by this release."
-    },
-    "statement_period": {
-      "type": "object",
-      "required": ["start", "end"],
-      "properties": {
-        "start": {
-          "type": "string",
-          "format": "date",
-          "description": "First calendar date covered by the statement, inclusive."
-        },
-        "end": {
-          "type": "string",
-          "format": "date",
-          "description": "Last calendar date covered by the statement, inclusive."
-        }
-      },
-      "additionalProperties": false
-    },
-    "currency": {
-      "const": "USD",
-      "description": "All monetary fields use US dollars. Mixed-currency records are invalid."
-    },
-    "card_volume": {
-      "$ref": "#/$defs/money",
-      "description": "Gross settled purchase volume for the statement period, before refunds, chargebacks, or funding adjustments."
-    },
-    "transaction_count": {
-      "type": "integer",
-      "minimum": 0,
-      "maximum": 1000000000,
-      "description": "Count of settled purchase transactions included in card_volume."
-    },
-    "gross_processing_fees": {
-      "$ref": "#/$defs/money",
-      "description": "Gross processing-related charges before statement_credits; equals the sum of fee_groups."
-    },
-    "statement_credits": {
-      "$ref": "#/$defs/money",
-      "description": "Processing-fee credits or rebates applied on the statement. Transaction refunds and funding adjustments are excluded."
-    },
-    "total_processing_fees": {
-      "$ref": "#/$defs/money",
-      "description": "Net processing fees: gross_processing_fees minus statement_credits."
-    },
-    "effective_rate": {
-      "description": "total_processing_fees divided by card_volume, expressed as a decimal rounded to six places; null when card_volume is zero.",
-      "oneOf": [
-        { "$ref": "#/$defs/rate" },
-        { "type": "null" }
-      ]
-    },
-    "average_ticket": {
-      "description": "card_volume divided by transaction_count, rounded to cents; null when transaction_count is zero.",
-      "oneOf": [
-        { "$ref": "#/$defs/money" },
-        { "type": "null" }
-      ]
-    },
-    "pricing_model": {
-      "type": "string",
-      "enum": [
-        "interchange_plus",
-        "flat_rate",
-        "tiered",
-        "subscription",
-        "dual_pricing",
-        "unknown"
-      ],
-      "description": "Observed statement pricing presentation, not a legal or qualification determination."
-    },
-    "fee_groups": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 9,
-      "description": "Gross, nonnegative processing charges grouped once by category. Categories must be unique.",
-      "items": {
-        "type": "object",
-        "required": ["category", "amount"],
-        "properties": {
-          "category": {
-            "type": "string",
-            "enum": [
-              "interchange",
-              "assessments",
-              "processor_markup",
-              "authorization",
-              "monthly",
-              "pci",
-              "equipment",
-              "chargebacks",
-              "other"
-            ]
-          },
-          "amount": { "$ref": "#/$defs/money" },
-          "notes": { "$ref": "#/$defs/note" }
-        },
-        "additionalProperties": false
-      }
-    },
-    "review_notes": {
-      "type": "array",
-      "maxItems": 20,
-      "items": { "$ref": "#/$defs/note" },
-      "description": "Optional audit explanations only. Never include merchant identity, card data, bank data, credentials, or secrets."
-    }
-  },
-  "$defs": {
-    "money": {
-      "type": "number",
-      "minimum": 0,
-      "maximum": 999999999999.99,
-      "description": "A nonnegative USD amount with no more than two decimal places. Decimal precision is enforced by the companion validator."
-    },
-    "rate": {
-      "type": "number",
-      "minimum": 0,
-      "description": "A nonnegative decimal rate with no more than six decimal places."
-    },
-    "note": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 500
-    }
-  },
-  "additionalProperties": false
-}

test-vectors/invalid/activity-mismatch.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":0.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":null,"average_ticket":0.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/duplicate-category.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":1.00},{"category":"processor_markup","amount":1.00}]
-}

test-vectors/invalid/fee-sum-mismatch.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.01,"statement_credits":0.00,"total_processing_fees":2.01,"effective_rate":0.020100,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/fractional-cent.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.001,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/invalid-date.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-02-01","end":"2026-02-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/net-fee-mismatch.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.50,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/overlong-period.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-01-01","end":"2026-04-01"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/overprecise-rate.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.0200001,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/pathological-number.json

@@ -1,4 +0,0 @@
-{
-  "schema_version": "1.1.0",
-  "card_volume": 1e-999999
-}

test-vectors/invalid/reversed-period.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-07-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/security-data-in-note.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}],"review_notes":["Synthetic security-code label with digits: CVV 123"]
-}

test-vectors/invalid/unknown-field.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}],"merchant_name":"Do not collect this"
-}

test-vectors/invalid/wrong-average-ticket.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":2,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/invalid/wrong-effective-rate.json

@@ -1,3 +0,0 @@
-{
-  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":2.000000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
-}

test-vectors/manifest.json

@@ -1,22 +0,0 @@
-{
-  "valid": [
-    "standard-month.json",
-    "zero-activity-month.json"
-  ],
-  "invalid": {
-    "activity-mismatch.json": ["activity_pair"],
-    "duplicate-category.json": ["duplicate_fee_category"],
-    "fee-sum-mismatch.json": ["fee_group_reconciliation"],
-    "fractional-cent.json": ["money_precision"],
-    "invalid-date.json": ["schema_format"],
-    "net-fee-mismatch.json": ["net_fee_reconciliation"],
-    "overlong-period.json": ["period_duration"],
-    "overprecise-rate.json": ["rate_precision"],
-    "pathological-number.json": ["number_range"],
-    "security-data-in-note.json": ["prohibited_payment_data"],
-    "reversed-period.json": ["period_order"],
-    "unknown-field.json": ["schema_additionalProperties"],
-    "wrong-average-ticket.json": ["average_ticket_mismatch"],
-    "wrong-effective-rate.json": ["effective_rate_mismatch"]
-  }
-}

test-vectors/valid/standard-month.json

@@ -1,23 +0,0 @@
-{
-  "schema_version": "1.1.0",
-  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
-  "statement_period": {"start": "2026-06-01", "end": "2026-06-30"},
-  "currency": "USD",
-  "card_volume": 125000.00,
-  "transaction_count": 1860,
-  "gross_processing_fees": 2864.75,
-  "statement_credits": 0.00,
-  "total_processing_fees": 2864.75,
-  "effective_rate": 0.022918,
-  "average_ticket": 67.20,
-  "pricing_model": "interchange_plus",
-  "fee_groups": [
-    {"category": "interchange", "amount": 1849.25},
-    {"category": "assessments", "amount": 171.50},
-    {"category": "processor_markup", "amount": 575.00},
-    {"category": "authorization", "amount": 186.00},
-    {"category": "monthly", "amount": 49.00},
-    {"category": "pci", "amount": 34.00}
-  ],
-  "review_notes": ["Synthetic validation vector only."]
-}

test-vectors/valid/zero-activity-month.json

@@ -1,16 +0,0 @@
-{
-  "schema_version": "1.1.0",
-  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
-  "statement_period": {"start": "2026-06-01", "end": "2026-06-30"},
-  "currency": "USD",
-  "card_volume": 0.00,
-  "transaction_count": 0,
-  "gross_processing_fees": 49.00,
-  "statement_credits": 0.00,
-  "total_processing_fees": 49.00,
-  "effective_rate": null,
-  "average_ticket": null,
-  "pricing_model": "unknown",
-  "fee_groups": [{"category": "monthly", "amount": 49.00}],
-  "review_notes": ["Synthetic zero-activity validation vector only."]
-}

tests/test_audit_validator.py

@@ -1,449 +0,0 @@
-import copy
-import importlib.util
-import json
-import shutil
-import subprocess
-import sys
-import tempfile
-import unittest
-from decimal import Decimal, Inexact, localcontext
-from pathlib import Path
-
-from jsonschema import Draft202012Validator
-
-
-ROOT = Path(__file__).resolve().parents[1]
-SCHEMA_PATH = ROOT / "schema/payment-statement-audit.schema.json"
-EXAMPLE_PATH = ROOT / "examples/payment-statement-audit-example.json"
-VALIDATOR_PATH = ROOT / "tools/validate_audit.py"
-
-
-def load_validator_module():
-    spec = importlib.util.spec_from_file_location("audit_validator", VALIDATOR_PATH)
-    if spec is None or spec.loader is None:
-        raise RuntimeError("Unable to load the audit validator")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-class AuditValidatorTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not VALIDATOR_PATH.is_file():
-            raise AssertionError("tools/validate_audit.py is required")
-        cls.validator = load_validator_module()
-        cls.valid_record = cls.validator.load_record(EXAMPLE_PATH)
-
-    def issue_codes(self, record):
-        return {issue.code for issue in self.validator.validate_record(record)}
-
-    def mutated(self, mutator):
-        record = copy.deepcopy(self.valid_record)
-        mutator(record)
-        return record
-
-    def test_schema_is_valid_draft_2020_12_and_example_passes_every_rule(self):
-        schema = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
-        Draft202012Validator.check_schema(schema)
-        self.assertEqual([], self.validator.validate_record(self.valid_record))
-
-    def test_json_loader_preserves_decimals_and_rejects_duplicate_keys(self):
-        self.assertIsInstance(self.valid_record["card_volume"], Decimal)
-        duplicate = '{"schema_version":"1.1.0","schema_version":"1.1.0"}'
-        with self.assertRaisesRegex(ValueError, "duplicate_key"):
-            self.validator.loads_record(duplicate)
-
-    def test_reversed_and_overlong_statement_periods_are_rejected(self):
-        reversed_record = self.mutated(
-            lambda row: row["statement_period"].update(
-                {"start": "2026-07-01", "end": "2026-06-30"}
-            )
-        )
-        overlong_record = self.mutated(
-            lambda row: row["statement_period"].update(
-                {"start": "2026-01-01", "end": "2026-04-01"}
-            )
-        )
-        self.assertIn("period_order", self.issue_codes(reversed_record))
-        self.assertIn("period_duration", self.issue_codes(overlong_record))
-
-    def test_invalid_calendar_dates_are_rejected_even_when_schema_format_is_annotation(self):
-        record = self.mutated(
-            lambda row: row["statement_period"].update({"end": "2026-02-30"})
-        )
-        self.assertIn("schema_format", self.issue_codes(record))
-
-    def test_fee_categories_must_be_unique_and_reconcile_to_gross_fees(self):
-        duplicate = self.mutated(
-            lambda row: row["fee_groups"].append(copy.deepcopy(row["fee_groups"][0]))
-        )
-        mismatch = self.mutated(
-            lambda row: row.update({"gross_processing_fees": Decimal("2864.74")})
-        )
-        self.assertIn("duplicate_fee_category", self.issue_codes(duplicate))
-        self.assertIn("fee_group_reconciliation", self.issue_codes(mismatch))
-
-    def test_statement_credits_reconcile_gross_and_net_processing_fees(self):
-        valid_credit = self.mutated(
-            lambda row: row.update(
-                {
-                    "statement_credits": Decimal("10.00"),
-                    "total_processing_fees": Decimal("2854.75"),
-                    "effective_rate": Decimal("0.022838"),
-                }
-            )
-        )
-        invalid_credit = self.mutated(
-            lambda row: row.update({"statement_credits": Decimal("10.00")})
-        )
-        self.assertEqual([], self.validator.validate_record(valid_credit))
-        self.assertIn("net_fee_reconciliation", self.issue_codes(invalid_credit))
-
-    def test_effective_rate_and_average_ticket_are_recomputed(self):
-        wrong_rate = self.mutated(
-            lambda row: row.update({"effective_rate": Decimal("2.291800")})
-        )
-        wrong_ticket = self.mutated(
-            lambda row: row.update({"average_ticket": Decimal("67.21")})
-        )
-        self.assertIn("effective_rate_mismatch", self.issue_codes(wrong_rate))
-        self.assertIn("average_ticket_mismatch", self.issue_codes(wrong_ticket))
-
-    def test_decimal_math_is_independent_of_the_callers_context(self):
-        with localcontext() as context:
-            context.prec = 4
-            context.Emax = 9
-            context.Emin = -9
-            context.traps[Inexact] = True
-            self.assertEqual([], self.validator.validate_record(self.valid_record))
-
-    def test_money_and_rate_precision_are_explicit(self):
-        fractional_cent = self.mutated(
-            lambda row: row.update({"card_volume": Decimal("125000.001")})
-        )
-        overprecise_rate = self.mutated(
-            lambda row: row.update({"effective_rate": Decimal("0.0229181")})
-        )
-        self.assertIn("money_precision", self.issue_codes(fractional_cent))
-        self.assertIn("rate_precision", self.issue_codes(overprecise_rate))
-
-    def test_zero_activity_semantics_are_unambiguous(self):
-        zero = self.mutated(
-            lambda row: row.update(
-                {
-                    "card_volume": Decimal("0.00"),
-                    "transaction_count": 0,
-                    "gross_processing_fees": Decimal("49.00"),
-                    "statement_credits": Decimal("0.00"),
-                    "total_processing_fees": Decimal("49.00"),
-                    "effective_rate": None,
-                    "average_ticket": None,
-                    "fee_groups": [
-                        {"category": "monthly", "amount": Decimal("49.00")}
-                    ],
-                }
-            )
-        )
-        inconsistent = self.mutated(
-            lambda row: row.update(
-                {"card_volume": Decimal("0.00"), "effective_rate": None}
-            )
-        )
-        self.assertEqual([], self.validator.validate_record(zero))
-        self.assertIn("activity_pair", self.issue_codes(inconsistent))
-
-        zero_fee = self.mutated(
-            lambda row: row.update(
-                {
-                    "card_volume": Decimal("0.00"),
-                    "transaction_count": 0,
-                    "gross_processing_fees": Decimal("0.00"),
-                    "statement_credits": Decimal("0.00"),
-                    "total_processing_fees": Decimal("0.00"),
-                    "effective_rate": None,
-                    "average_ticket": None,
-                    "fee_groups": [
-                        {"category": "other", "amount": Decimal("0.00")}
-                    ],
-                }
-            )
-        )
-        self.assertEqual([], self.validator.validate_record(zero_fee))
-
-    def test_published_half_up_rounding_is_enforced_at_exact_ties(self):
-        average_ticket_tie = self.mutated(
-            lambda row: row.update(
-                {
-                    "card_volume": Decimal("0.01"),
-                    "transaction_count": 2,
-                    "gross_processing_fees": Decimal("0.00"),
-                    "statement_credits": Decimal("0.00"),
-                    "total_processing_fees": Decimal("0.00"),
-                    "effective_rate": Decimal("0.000000"),
-                    "average_ticket": Decimal("0.01"),
-                    "fee_groups": [
-                        {"category": "other", "amount": Decimal("0.00")}
-                    ],
-                }
-            )
-        )
-        effective_rate_tie = self.mutated(
-            lambda row: row.update(
-                {
-                    "card_volume": Decimal("20000.00"),
-                    "transaction_count": 1,
-                    "gross_processing_fees": Decimal("0.01"),
-                    "statement_credits": Decimal("0.00"),
-                    "total_processing_fees": Decimal("0.01"),
-                    "effective_rate": Decimal("0.000001"),
-                    "average_ticket": Decimal("20000.00"),
-                    "fee_groups": [
-                        {"category": "other", "amount": Decimal("0.01")}
-                    ],
-                }
-            )
-        )
-        self.assertEqual([], self.validator.validate_record(average_ticket_tie))
-        self.assertEqual([], self.validator.validate_record(effective_rate_tie))
-
-    def test_non_finite_numbers_and_unknown_fields_are_rejected(self):
-        with self.assertRaisesRegex(ValueError, "non_finite_number"):
-            self.validator.loads_record('{"card_volume": NaN}')
-        unknown = self.mutated(lambda row: row.update({"merchant_name": "Example"}))
-        self.assertIn("schema_additionalProperties", self.issue_codes(unknown))
-
-    def test_pathological_number_literals_fail_closed_without_decimal_crashes(self):
-        hostile_literals = (
-            '{"card_volume":1e-999999}',
-            '{"effective_rate":1e999999}',
-            '{"transaction_count":' + ("9" * 5000) + "}",
-        )
-        for source in hostile_literals:
-            with self.subTest(source_length=len(source)):
-                with self.assertRaisesRegex(ValueError, "number_range"):
-                    self.validator.loads_record(source)
-
-        direct_record = self.mutated(
-            lambda row: row.update({"card_volume": Decimal("1e-999999")})
-        )
-        self.assertIn("number_range", self.issue_codes(direct_record))
-
-    def test_direct_nonfinite_and_extreme_numbers_are_safe_rejections(self):
-        hostile_values = (
-            Decimal("Infinity"),
-            Decimal("NaN"),
-            Decimal("1e999999"),
-            float("inf"),
-            float("nan"),
-            10**32,
-            10**5000,
-        )
-        for value in hostile_values:
-            with self.subTest(value_type=type(value).__name__):
-                record = self.mutated(
-                    lambda row, hostile=value: row.update({"card_volume": hostile})
-                )
-                self.assertIn("number_range", self.issue_codes(record))
-
-    def test_oversized_and_deeply_nested_inputs_fail_closed(self):
-        oversized = '{"review_notes":["' + ("x" * 1_000_000) + '"]}'
-        with self.assertRaisesRegex(ValueError, "input_size"):
-            self.validator.loads_record(oversized)
-
-        nested = "{}"
-        for _ in range(40):
-            nested = '{"unknown":' + nested + "}"
-        with self.assertRaisesRegex(ValueError, "input_depth"):
-            self.validator.loads_record(nested)
-
-    def test_malformed_nested_shapes_return_issues_instead_of_crashing(self):
-        malformed_records = [
-            {"statement_period": []},
-            {"fee_groups": [None, [], {"amount": []}]},
-            {"statement_period": {"start": [], "end": {}}},
-            {"review_notes": [{"unexpected": [1, 2, 3]}]},
-        ]
-        for record in malformed_records:
-            with self.subTest(record=record):
-                issues = self.validator.validate_record(record)
-                self.assertTrue(issues)
-
-    def test_luhn_pan_and_contextual_security_data_in_notes_are_rejected(self):
-        pan = self.mutated(
-            lambda row: row.update(
-                {"review_notes": ["Card number 4111 1111 1111 1111"]}
-            )
-        )
-        cvv = self.mutated(
-            lambda row: row.update({"review_notes": ["CVV 123"]})
-        )
-        self.assertIn("prohibited_payment_data", self.issue_codes(pan))
-        self.assertIn("prohibited_payment_data", self.issue_codes(cvv))
-
-    def test_identity_bank_and_credential_values_in_notes_are_rejected(self):
-        prohibited_notes = (
-            "Owner email is merchant@example.com",
-            "Owner SSN is 123-45-6789",
-            "Routing number: 021000021",
-            "Password is CorrectHorseBatteryStaple",
-        )
-        for note in prohibited_notes:
-            with self.subTest(note_kind=note.split()[0].lower()):
-                record = self.mutated(
-                    lambda row, value=note: row.update({"review_notes": [value]})
-                )
-                self.assertIn("prohibited_payment_data", self.issue_codes(record))
-
-    def test_errors_never_echo_input_values(self):
-        sensitive = "4111 1111 1111 1111"
-        record = self.mutated(
-            lambda row: row.update({"review_notes": [f"Card number {sensitive}"]})
-        )
-        report = self.validator.validation_result(record)
-        rendered = json.dumps(report, sort_keys=True)
-        self.assertNotIn(sensitive, rendered)
-        self.assertEqual("invalid", report["status"])
-
-    def test_unknown_field_names_never_leak_through_issue_paths(self):
-        sensitive_key = "password_SUPERSECRET_12345"
-        record = {sensitive_key: Decimal("1e999999")}
-        rendered = json.dumps(
-            self.validator.validation_result(record), sort_keys=True
-        )
-        self.assertNotIn(sensitive_key, rendered)
-        self.assertIn("/_unknown", rendered)
-
-    def test_csv_header_matches_the_documented_flat_contract(self):
-        issues = self.validator.validate_csv_template(
-            ROOT / "payment-statement-audit-template.csv"
-        )
-        self.assertEqual([], issues)
-
-    def test_csv_rejects_spreadsheet_formula_payloads_without_echoing_them(self):
-        formula_prefixes = (
-            "=1+1",
-            "+1+1",
-            "-1+1",
-            "@SUM(1)",
-            "\t=1+1",
-            "\ufeff=1+1",
-        )
-        for marker in formula_prefixes:
-            with self.subTest(prefix=marker[0]):
-                with tempfile.TemporaryDirectory() as directory:
-                    candidate = Path(directory) / "statement.csv"
-                    source = (
-                        ROOT / "payment-statement-audit-template.csv"
-                    ).read_text(encoding="utf-8")
-                    lines = source.splitlines()
-                    lines[1] = lines[1].rsplit(",", maxsplit=1)[0] + "," + marker
-                    candidate.write_text(
-                        "\n".join(lines) + "\n", encoding="utf-8"
-                    )
-
-                    issues = self.validator.validate_csv_template(candidate)
-                    self.assertIn("csv_formula", {issue.code for issue in issues})
-                    self.assertNotIn(
-                        marker, json.dumps([issue.to_dict() for issue in issues])
-                    )
-
-    def test_shipped_corpus_has_broad_expected_failure_coverage(self):
-        report = self.validator.build_corpus_report(ROOT)
-        self.assertEqual("pass", report["status"])
-        self.assertGreaterEqual(report["valid_vectors"], 2)
-        self.assertGreaterEqual(report["invalid_vectors"], 12)
-        self.assertEqual(0, report["unexpected_results"])
-        self.assertIn("schema_sha256", report)
-        self.assertIn("validator_sha256", report)
-
-    def test_corpus_report_records_the_complete_pinned_validation_runtime(self):
-        report = self.validator.build_corpus_report(ROOT)
-        expected = {
-            "attrs",
-            "jsonschema",
-            "jsonschema-specifications",
-            "referencing",
-            "rpds-py",
-        }
-        self.assertEqual(expected, set(report["dependency_versions"]))
-        pins = {
-            line.split("==", maxsplit=1)[0]: line.split("==", maxsplit=1)[1]
-            for line in (ROOT / "requirements-validation.txt")
-            .read_text(encoding="utf-8")
-            .splitlines()
-            if line and not line.startswith("#")
-        }
-        self.assertEqual(report["dependency_versions"], pins)
-
-    def test_cli_returns_nonzero_and_machine_readable_safe_output_for_invalid_input(self):
-        invalid_path = ROOT / "test-vectors/invalid/security-data-in-note.json"
-        result = subprocess.run(
-            [sys.executable, str(VALIDATOR_PATH), "--json", str(invalid_path)],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        self.assertEqual(1, result.returncode)
-        report = json.loads(result.stdout)
-        self.assertEqual("invalid", report["status"])
-        self.assertNotIn("4111", result.stdout)
-
-    def test_cli_uses_a_stable_value_free_code_for_unreadable_input(self):
-        marker = "private-merchant-statement-do-not-echo.json"
-        result = subprocess.run(
-            [sys.executable, str(VALIDATOR_PATH), "--json", str(ROOT / marker)],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        self.assertEqual(1, result.returncode)
-        report = json.loads(result.stdout)
-        self.assertEqual("input_read", report["issues"][0]["code"])
-        self.assertNotIn(marker, result.stdout)
-
-    def test_corpus_reports_a_missing_vector_without_throwing(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "test-vectors/invalid/wrong-effective-rate.json").unlink()
-
-            report = self.validator.build_corpus_report(candidate)
-            self.assertEqual("fail", report["status"])
-            self.assertGreaterEqual(report["unexpected_results"], 1)
-
-    def test_corpus_rejects_a_missing_registered_valid_vector(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "test-vectors/valid/standard-month.json").unlink()
-
-            report = self.validator.build_corpus_report(candidate)
-            self.assertEqual("fail", report["status"])
-            self.assertIn(
-                {"file": "valid-corpus", "result": "inventory_mismatch"},
-                report["unexpected"],
-            )
-
-    def test_corpus_rejects_an_unregistered_invalid_vector(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            shutil.copyfile(
-                candidate / "test-vectors/valid/standard-month.json",
-                candidate / "test-vectors/invalid/unregistered.json",
-            )
-
-            report = self.validator.build_corpus_report(candidate)
-            self.assertEqual("fail", report["status"])
-            self.assertIn(
-                {"file": "invalid-corpus", "result": "inventory_mismatch"},
-                report["unexpected"],
-            )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_public_release_attestation.py

@@ -1,329 +0,0 @@
-import hashlib
-import importlib.util
-import io
-import sys
-import tempfile
-import unittest
-import zipfile
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[1]
-ATTESTATION_PATH = ROOT / "tools/public_release_attestation.py"
-TITLE = "Lifted Payments Payment Statement Audit Model"
-CANONICAL_URL = "https://liftedpayments.com/payment-processing-statement-audit/"
-SOURCE_REPOSITORY = "https://github.com/Lifted-Holdings/payment-processing-resources"
-
-
-def load_module(path: Path, name: str):
-    spec = importlib.util.spec_from_file_location(name, path)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"Unable to load {name}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-class FakeTransport:
-    def __init__(self, *, json_values, byte_values, final_urls):
-        self.json_values = json_values
-        self.byte_values = byte_values
-        self.final_urls = final_urls
-
-    def get_json(self, url, *, max_bytes):
-        del max_bytes
-        return self.json_values[url]
-
-    def get_bytes(self, url, *, max_bytes):
-        value = self.byte_values[url]
-        if len(value) > max_bytes:
-            raise ValueError("response_too_large")
-        return value
-
-    def resolve(self, url, *, max_bytes):
-        del max_bytes
-        return self.final_urls[url]
-
-
-class PublicReleaseAttestationTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not ATTESTATION_PATH.is_file():
-            raise AssertionError("tools/public_release_attestation.py is required")
-        cls.attestation = load_module(ATTESTATION_PATH, "public_release_attestation")
-
-    def setUp(self):
-        self.temporary_directory = tempfile.TemporaryDirectory()
-        self.root = Path(self.temporary_directory.name)
-        (self.root / "README.md").write_text("verified release\n", encoding="utf-8")
-        self.manifest = {
-            "title": TITLE,
-            "version": "1.1.3",
-            "release_date": "2026-08-02",
-            "version_doi": "10.5281/zenodo.99999999",
-            "concept_doi": "10.5281/zenodo.21761714",
-            "canonical_url": CANONICAL_URL,
-            "source_release": f"{SOURCE_REPOSITORY}/releases/tag/v1.1.3",
-            "license": "CC-BY-4.0",
-            "files": ["README.md"],
-        }
-
-    def tearDown(self):
-        self.temporary_directory.cleanup()
-
-    def make_zip(self, members=None):
-        members = members or {"README.md": (self.root / "README.md").read_bytes()}
-        output = io.BytesIO()
-        with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_DEFLATED) as archive:
-            for name, value in members.items():
-                archive.writestr(f"payment-processing-resources-1.1.3/{name}", value)
-        return output.getvalue()
-
-    def make_transport(self, archive=None):
-        archive = archive or self.make_zip()
-        digest = hashlib.sha256(archive).hexdigest()
-        zip_name = "lifted-payments-statement-audit-model-v1.1.3.zip"
-        sidecar_name = "release-archive.sha256"
-        github_zip = (
-            f"https://github.com/Lifted-Holdings/payment-processing-resources/"
-            f"releases/download/v1.1.3/{zip_name}"
-        )
-        github_sidecar = (
-            "https://github.com/Lifted-Holdings/payment-processing-resources/"
-            f"releases/download/v1.1.3/{sidecar_name}"
-        )
-        zenodo_zip = (
-            f"https://zenodo.org/api/records/99999999/files/{zip_name}/content"
-        )
-        zenodo_sidecar = (
-            f"https://zenodo.org/api/records/99999999/files/{sidecar_name}/content"
-        )
-        huggingface_zip = (
-            "https://huggingface.co/datasets/Liftedholdings/"
-            f"payment-statement-audit-model/resolve/main/{zip_name}"
-        )
-        sidecar = f"{digest}  {zip_name}\n".encode()
-        github = {
-            "tag_name": "v1.1.3",
-            "draft": False,
-            "prerelease": False,
-            "html_url": self.manifest["source_release"],
-            "assets": [
-                {
-                    "name": zip_name,
-                    "size": len(archive),
-                    "digest": f"sha256:{digest}",
-                    "browser_download_url": github_zip,
-                },
-                {
-                    "name": sidecar_name,
-                    "size": len(sidecar),
-                    "digest": f"sha256:{hashlib.sha256(sidecar).hexdigest()}",
-                    "browser_download_url": github_sidecar,
-                },
-            ],
-        }
-        zenodo = {
-            "id": 99999999,
-            "doi": self.manifest["version_doi"],
-            "conceptdoi": self.manifest["concept_doi"],
-            "metadata": {
-                "title": TITLE,
-                "publication_date": "2026-08-02",
-                "version": "1.1.3",
-                "license": {"id": "cc-by-4.0"},
-                "related_identifiers": [
-                    {"identifier": CANONICAL_URL, "relation": "isDocumentedBy"},
-                    {
-                        "identifier": self.manifest["source_release"],
-                        "relation": "isSourceOf",
-                    },
-                ],
-            },
-            "files": [
-                {
-                    "key": zip_name,
-                    "size": len(archive),
-                    "checksum": f"md5:{hashlib.md5(archive).hexdigest()}",
-                    "links": {"self": zenodo_zip},
-                },
-                {
-                    "key": sidecar_name,
-                    "size": len(sidecar),
-                    "checksum": f"md5:{hashlib.md5(sidecar).hexdigest()}",
-                    "links": {"self": zenodo_sidecar},
-                },
-            ],
-        }
-        huggingface = {
-            "id": "Liftedholdings/payment-statement-audit-model",
-            "sha": "a" * 40,
-            "private": False,
-            "disabled": False,
-            "gated": False,
-            "siblings": [{"rfilename": zip_name}],
-        }
-        snapshot_id = "c" * 40
-        release_id = "d" * 40
-        expected_commit = "b" * 40
-        software_heritage_visit = (
-            "https://archive.softwareheritage.org/api/1/origin/"
-            "https%3A%2F%2Fgithub.com%2FLifted-Holdings%2F"
-            "payment-processing-resources/visit/latest/?require_snapshot=true"
-        )
-        software_heritage_snapshot = (
-            f"https://archive.softwareheritage.org/api/1/snapshot/{snapshot_id}/"
-        )
-        software_heritage_release = (
-            f"https://archive.softwareheritage.org/api/1/release/{release_id}/"
-        )
-        transport = FakeTransport(
-            json_values={
-                "https://api.github.com/repos/Lifted-Holdings/payment-processing-resources/releases/tags/v1.1.3": github,
-                "https://zenodo.org/api/records/99999999": zenodo,
-                "https://huggingface.co/api/datasets/Liftedholdings/payment-statement-audit-model": huggingface,
-                software_heritage_visit: {
-                    "origin": SOURCE_REPOSITORY,
-                    "status": "full",
-                    "snapshot": snapshot_id,
-                },
-                software_heritage_snapshot: {
-                    "id": snapshot_id,
-                    "branches": {
-                        "refs/heads/main": {
-                            "target": expected_commit,
-                            "target_type": "revision",
-                        },
-                        "refs/tags/v1.1.3": {
-                            "target": release_id,
-                            "target_type": "release",
-                        },
-                    },
-                },
-                software_heritage_release: {
-                    "id": release_id,
-                    "name": "v1.1.3",
-                    "target": expected_commit,
-                    "target_type": "revision",
-                },
-            },
-            byte_values={
-                github_zip: archive,
-                github_sidecar: sidecar,
-                zenodo_zip: archive,
-                zenodo_sidecar: sidecar,
-                huggingface_zip: archive,
-            },
-            final_urls={
-                "https://doi.org/10.5281/zenodo.99999999": "https://zenodo.org/records/99999999"
-            },
-        )
-        return transport, digest, expected_commit, snapshot_id
-
-    def test_matching_github_zenodo_doi_and_huggingface_artifacts_verify(self):
-        transport, digest, expected_commit, snapshot_id = self.make_transport()
-
-        result = self.attestation.attest_public_release(
-            self.root,
-            self.manifest,
-            transport=transport,
-            expected_commit=expected_commit,
-        )
-
-        self.assertTrue(result.verified, result.failure_codes)
-        self.assertEqual((), result.failure_codes)
-        self.assertEqual(digest, result.archive_sha256)
-        self.assertEqual(snapshot_id, result.software_heritage_snapshot)
-
-    def test_digest_mismatch_blocks_attestation(self):
-        transport, _, expected_commit, _ = self.make_transport()
-        github_url = next(
-            url for url in transport.byte_values if url.startswith("https://github.com")
-            and url.endswith(".zip")
-        )
-        transport.byte_values[github_url] += b"tampered"
-
-        result = self.attestation.attest_public_release(
-            self.root,
-            self.manifest,
-            transport=transport,
-            expected_commit=expected_commit,
-        )
-
-        self.assertFalse(result.verified)
-        self.assertIn("github_archive_digest_mismatch", result.failure_codes)
-
-    def test_zip_traversal_and_duplicate_aliases_are_rejected(self):
-        cases = {
-            "traversal": {
-                "README.md": b"verified release\n",
-                "../outside.txt": b"outside",
-            },
-            "case_alias": {
-                "README.md": b"verified release\n",
-                "readme.md": b"alias",
-            },
-        }
-        for name, members in cases.items():
-            with self.subTest(name=name):
-                archive = self.make_zip(members)
-                transport, _, expected_commit, _ = self.make_transport(archive)
-                result = self.attestation.attest_public_release(
-                    self.root,
-                    self.manifest,
-                    transport=transport,
-                    expected_commit=expected_commit,
-                )
-                self.assertFalse(result.verified)
-                self.assertIn("release_archive_invalid", result.failure_codes)
-
-    def test_http_transport_rejects_untrusted_or_insecure_hosts_before_request(self):
-        transport = self.attestation.HttpTransport()
-        for url in (
-            "http://github.com/Lifted-Holdings/example",
-            "https://github.com.evil.invalid/payload",
-            "https://evil.invalid/payload",
-        ):
-            with self.subTest(url=url):
-                with self.assertRaises(ValueError):
-                    transport.get_bytes(url, max_bytes=1024)
-
-    def test_doi_resolution_requests_the_human_html_landing_page(self):
-        observed = {}
-
-        class Response:
-            headers = {}
-
-            def __enter__(self):
-                return self
-
-            def __exit__(self, exc_type, exc, traceback):
-                return False
-
-            def geturl(self):
-                return "https://zenodo.org/records/99999999"
-
-            def read(self, size):
-                del size
-                return b""
-
-        class Opener:
-            def open(self, request, timeout):
-                del timeout
-                observed["accept"] = request.headers["Accept"]
-                return Response()
-
-        transport = self.attestation.HttpTransport()
-        transport._opener = Opener()
-
-        resolved = transport.resolve(
-            "https://doi.org/10.5281/zenodo.99999999", max_bytes=1024
-        )
-
-        self.assertEqual("https://zenodo.org/records/99999999", resolved)
-        self.assertEqual("text/html, application/xhtml+xml", observed["accept"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_publication_gate.py

@@ -1,574 +0,0 @@
-import importlib.util
-import json
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from types import SimpleNamespace
-from unittest import mock
-
-
-ROOT = Path(__file__).resolve().parents[1]
-GATE_PATH = ROOT / "tools/publication_gate.py"
-MANIFEST_PATH = ROOT / "RELEASE-MANIFEST.json"
-
-
-def load_module(path: Path, name: str):
-    spec = importlib.util.spec_from_file_location(name, path)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"Unable to load {name}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-class PublicationGateTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not GATE_PATH.is_file():
-            raise AssertionError("tools/publication_gate.py is required")
-        cls.gate = load_module(GATE_PATH, "publication_gate")
-
-    def test_release_manifest_has_one_explicit_versioned_identity(self):
-        manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
-        self.assertEqual("1.1.3", manifest["version"])
-        self.assertEqual("1.1.0", manifest["schema_version"])
-        self.assertEqual(
-            "10.5281/zenodo.21761714", manifest["concept_doi"]
-        )
-        self.assertEqual(
-            "https://liftedpayments.com/payment-processing-statement-audit/",
-            manifest["canonical_url"],
-        )
-        self.assertTrue(manifest["source_release"].endswith("/releases/tag/v1.1.3"))
-        self.assertEqual(len(manifest["files"]), len(set(manifest["files"])))
-        self.assertGreaterEqual(len(manifest["files"]), 20)
-
-    def test_gate_is_fail_closed_until_every_release_condition_is_satisfied(self):
-        report = self.gate.build_publication_report(ROOT)
-        self.assertIn(report["status"], {"blocked", "valid", "ready", "verified"})
-        self.assertEqual("candidate", report["mode"])
-        self.assertEqual(report["check_count"], len(report["checks"]))
-        self.assertEqual(
-            report["failed_check_count"],
-            sum(check["status"] == "fail" for check in report["checks"]),
-        )
-        self.assertIn("corpus_validation", {check["code"] for check in report["checks"]})
-        self.assertIn("dependency_lock", {check["code"] for check in report["checks"]})
-        self.assertIn("utf8_text_assets", {check["code"] for check in report["checks"]})
-        self.assertIn(
-            "repository_provenance", {check["code"] for check in report["checks"]}
-        )
-        manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
-        if manifest["version_doi"] is None:
-            self.assertEqual("blocked", report["status"])
-            self.assertIn(
-                "version_doi_declared",
-                {check["code"] for check in report["checks"] if check["status"] == "fail"},
-            )
-
-    def test_tagless_tree_is_blocked_in_default_candidate_mode(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate, ignore=shutil.ignore_patterns(".git"))
-
-            report = self.gate.build_publication_report(candidate)
-
-        checks = {check["code"]: check["status"] for check in report["checks"]}
-        self.assertEqual("candidate", report["mode"])
-        self.assertEqual("blocked", report["status"])
-        self.assertEqual("fail", checks["repository_provenance"])
-
-    def test_tagless_tree_can_be_package_valid_but_never_publication_ready(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate, ignore=shutil.ignore_patterns(".git"))
-
-            report = self.gate.build_publication_report(candidate, mode="package")
-
-        self.assertEqual("package", report["mode"])
-        self.assertEqual("valid", report["status"])
-        self.assertNotIn(
-            "repository_provenance", {check["code"] for check in report["checks"]}
-        )
-
-    def test_provenance_failure_prevents_candidate_validator_execution(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate, ignore=shutil.ignore_patterns(".git"))
-            validator = candidate / "tools/validate_audit.py"
-            validator.write_text(
-                "from pathlib import Path\n"
-                "Path('candidate-validator-executed.marker').write_text('executed')\n"
-                "raise SystemExit(1)\n",
-                encoding="utf-8",
-            )
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-
-            self.assertEqual("blocked", report["status"])
-            self.assertFalse((candidate / "candidate-validator-executed.marker").exists())
-
-    def test_cli_package_mode_uses_package_validity_language(self):
-        result = subprocess.run(
-            [sys.executable, str(GATE_PATH), "--mode", "package", "--json"],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        report = json.loads(result.stdout)
-        self.assertEqual("package", report["mode"])
-        self.assertEqual("valid", report["status"])
-        self.assertEqual(0, result.returncode)
-
-    def test_published_mode_requires_and_reports_external_attestation(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate, ignore=shutil.ignore_patterns(".git"))
-            with mock.patch.object(
-                self.gate,
-                "inspect_repository",
-                return_value=SimpleNamespace(
-                    publication_ready=True, head_commit="a" * 40
-                ),
-            ), mock.patch.object(
-                self.gate,
-                "attest_public_release",
-                return_value=SimpleNamespace(verified=True),
-            ) as attestor:
-                report = self.gate.build_publication_report(candidate, mode="published")
-
-        checks = {check["code"]: check["status"] for check in report["checks"]}
-        self.assertEqual("verified", report["status"])
-        self.assertEqual("pass", checks["public_release_attestation"])
-        attestor.assert_called_once()
-
-    def test_published_mode_blocks_when_external_attestation_disagrees(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate, ignore=shutil.ignore_patterns(".git"))
-            with mock.patch.object(
-                self.gate,
-                "inspect_repository",
-                return_value=SimpleNamespace(
-                    publication_ready=True, head_commit="a" * 40
-                ),
-            ), mock.patch.object(
-                self.gate,
-                "attest_public_release",
-                return_value=SimpleNamespace(verified=False),
-            ):
-                report = self.gate.build_publication_report(candidate, mode="published")
-
-        checks = {check["code"]: check["status"] for check in report["checks"]}
-        self.assertEqual("blocked", report["status"])
-        self.assertEqual("fail", checks["public_release_attestation"])
-
-    def test_gate_report_contains_hashes_and_no_file_contents(self):
-        report = self.gate.build_publication_report(ROOT)
-        rendered = json.dumps(report, sort_keys=True)
-        self.assertIn("manifest_sha256", report)
-        self.assertRegex(report["manifest_sha256"], r"^[0-9a-f]{64}$")
-        self.assertNotIn("4111 1111", rendered)
-        self.assertNotIn("CVV 123", rendered)
-        for check in report["checks"]:
-            self.assertEqual(
-                {"code", "status", "message"}, set(check), "gate checks must stay value-free"
-            )
-
-    def test_cli_exit_code_matches_release_readiness(self):
-        result = subprocess.run(
-            [sys.executable, str(GATE_PATH), "--json"],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        report = json.loads(result.stdout)
-        expected = 0 if report["status"] == "ready" else 1
-        self.assertEqual(expected, result.returncode)
-
-    def test_checksum_tool_verifies_the_exact_manifest_without_rewriting(self):
-        result = subprocess.run(
-            [sys.executable, "tools/update_checksums.py", "--check"],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        self.assertEqual(0, result.returncode, result.stdout + result.stderr)
-        self.assertEqual("checksums.txt is current\n", result.stdout)
-
-    def test_gate_scans_every_declared_asset_for_common_secret_signatures(self):
-        signatures = (
-            "AKIA" + "IOSFODNN7EXAMPLE",
-            "sk-proj-" + ("A" * 32),
-            "sk-ant-" + ("B" * 32),
-            "ya29." + ("C" * 32),
-        )
-        for signature in signatures:
-            with self.subTest(prefix=signature[:7]):
-                with tempfile.TemporaryDirectory() as directory:
-                    candidate = Path(directory) / "release"
-                    shutil.copytree(ROOT, candidate)
-                    with (candidate / "LICENSE.md").open(
-                        "a", encoding="utf-8"
-                    ) as handle:
-                        handle.write("\n" + signature + "\n")
-
-                    report = self.gate.build_publication_report(candidate)
-                    checks = {
-                        check["code"]: check["status"] for check in report["checks"]
-                    }
-                    self.assertEqual("fail", checks["public_content_safety"])
-                    self.assertEqual("blocked", report["status"])
-
-    def test_gate_executes_the_validator_from_the_candidate_release(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "tools/validate_audit.py").write_text(
-                'raise RuntimeError("tampered validator")\n', encoding="utf-8"
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("fail", checks["corpus_validation"])
-            self.assertEqual("blocked", report["status"])
-
-    def test_gate_requires_every_security_critical_release_asset(self):
-        critical_assets = (
-            "tools/public_release_attestation.py",
-            "tools/publication_gate.py",
-            "tools/release_provenance.py",
-            "tests/test_public_release_attestation.py",
-            "tests/test_release_provenance.py",
-        )
-        for critical_asset in critical_assets:
-            with self.subTest(critical_asset=critical_asset):
-                with tempfile.TemporaryDirectory() as directory:
-                    candidate = Path(directory) / "release"
-                    shutil.copytree(ROOT, candidate)
-                    manifest_path = candidate / "RELEASE-MANIFEST.json"
-                    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-                    manifest["files"].remove(critical_asset)
-                    manifest_path.write_text(
-                        json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
-                    )
-
-                    report = self.gate.build_publication_report(candidate)
-                    checks = {
-                        check["code"]: check["status"] for check in report["checks"]
-                    }
-                    self.assertEqual("fail", checks["required_release_assets"])
-                    self.assertEqual("blocked", report["status"])
-
-    def test_gate_blocks_an_undeclared_regular_file_in_the_release_tree(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "undeclared-public-payload.txt").write_text(
-                "This file is not covered by the manifest or checksums.\n",
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("fail", checks["manifest_inventory"])
-            self.assertEqual("blocked", report["status"])
-
-    def test_gate_blocks_an_oversized_declared_text_asset(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            oversized_name = "oversized-public-payload.txt"
-            (candidate / oversized_name).write_bytes(b"x" * (5 * 1024 * 1024 + 1))
-            manifest_path = candidate / "RELEASE-MANIFEST.json"
-            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-            manifest["files"].append(oversized_name)
-            manifest_path.write_text(
-                json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
-            )
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("fail", checks["release_size_limits"])
-            self.assertEqual("blocked", report["status"])
-
-    def test_gate_runs_the_candidate_validator_regression_suite(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            validator_path = candidate / "tools/validate_audit.py"
-            validator = validator_path.read_text(encoding="utf-8")
-            validator = validator.replace(
-                '_EMAIL = re.compile(r"\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b", re.I)',
-                '_EMAIL = re.compile(r"$^")',
-            )
-            self.assertIn('_EMAIL = re.compile(r"$^")', validator)
-            validator_path.write_text(validator, encoding="utf-8")
-
-            corpus = subprocess.run(
-                [sys.executable, "tools/validate_audit.py", "--corpus"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-            (candidate / "validation-report.json").write_text(
-                corpus.stdout, encoding="utf-8"
-            )
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("fail", checks["candidate_regression_suite"])
-            self.assertEqual("blocked", report["status"])
-
-    def test_gate_rejects_untrusted_manifest_identity_even_when_metadata_agrees(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            manifest_path = candidate / "RELEASE-MANIFEST.json"
-            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-            old_concept_doi = manifest["concept_doi"]
-            manifest["concept_doi"] = "not-a-doi"
-            manifest_path.write_text(
-                json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
-            )
-
-            codemeta_path = candidate / "codemeta.json"
-            codemeta = json.loads(codemeta_path.read_text(encoding="utf-8"))
-            codemeta["sameAs"] = [
-                value.replace(
-                    f"https://doi.org/{old_concept_doi}",
-                    "https://doi.org/not-a-doi",
-                )
-                for value in codemeta["sameAs"]
-            ]
-            codemeta_path.write_text(
-                json.dumps(codemeta, indent=2) + "\n", encoding="utf-8"
-            )
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("fail", checks["manifest_identity"])
-            self.assertEqual("blocked", report["status"])
-
-    def test_gate_blocks_changes_masquerading_as_an_existing_release_tag(self):
-        tag_check = subprocess.run(
-            ["git", "rev-parse", "--verify", "refs/tags/v1.1.1"],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if tag_check.returncode != 0:
-            self.skipTest("v1.1.1 tag is required for the immutability regression")
-
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            with (candidate / "README.md").open("a", encoding="utf-8") as handle:
-                handle.write("\nUndisclosed rewrite of an immutable release.\n")
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            manifest = json.loads(
-                (candidate / "RELEASE-MANIFEST.json").read_text(encoding="utf-8")
-            )
-            manifest["version"] = "1.1.1"
-            self.assertFalse(
-                self.gate._matches_existing_release_tag(
-                    candidate, manifest, manifest["files"]
-                )
-            )
-
-    def test_gate_returns_a_structured_block_for_a_malformed_manifest(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "RELEASE-MANIFEST.json").write_text(
-                "{not-json", encoding="utf-8"
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            self.assertEqual("blocked", report["status"])
-            self.assertEqual("manifest_read", report["checks"][0]["code"])
-            self.assertEqual("fail", report["checks"][0]["status"])
-
-    def test_manifest_traversal_is_blocked_without_reading_outside_release(self):
-        with tempfile.TemporaryDirectory() as directory:
-            parent = Path(directory)
-            candidate = parent / "release"
-            shutil.copytree(ROOT, candidate)
-            (parent / "outside.txt").write_text(
-                "AKIA" + "IOSFODNN7EXAMPLE", encoding="utf-8"
-            )
-            manifest_path = candidate / "RELEASE-MANIFEST.json"
-            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-            manifest["files"].append("../outside.txt")
-            manifest_path.write_text(
-                json.dumps(manifest, indent=2) + "\n", encoding="utf-8"
-            )
-
-            paths, safe = self.gate._safe_file_paths(candidate, manifest["files"])
-            self.assertFalse(safe)
-            self.assertNotIn((parent / "outside.txt").resolve(), paths)
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("blocked", report["status"])
-            self.assertEqual("fail", checks["manifest_inventory"])
-            self.assertEqual("fail", checks["public_content_safety"])
-
-    def test_manifest_rejects_noncanonical_aliases_of_the_same_file(self):
-        paths, safe = self.gate._safe_file_paths(
-            ROOT, ["README.md", "./README.md"]
-        )
-        self.assertFalse(safe)
-        self.assertEqual([ROOT / "README.md"], paths)
-
-    def test_gate_blocks_a_missing_identity_asset_without_throwing(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "README.md").unlink()
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("blocked", report["status"])
-            self.assertEqual("fail", checks["manifest_inventory"])
-            self.assertEqual("fail", checks["release_identity"])
-
-    def test_gate_blocks_non_utf8_integrity_metadata_without_throwing(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            (candidate / "checksums.txt").write_bytes(b"\xff\xfe\x00")
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("blocked", report["status"])
-            self.assertEqual("fail", checks["release_checksums"])
-            self.assertEqual("fail", checks["utf8_text_assets"])
-
-    def test_gate_rejects_an_artifact_beneath_a_symlinked_directory(self):
-        with tempfile.TemporaryDirectory() as directory:
-            parent = Path(directory)
-            candidate = parent / "release"
-            shutil.copytree(ROOT, candidate)
-            target = candidate / "real-assets"
-            target.mkdir()
-            (target / "nested.txt").write_text("safe", encoding="utf-8")
-            alias = candidate / "alias"
-            try:
-                os.symlink(target, alias, target_is_directory=True)
-            except OSError as exc:
-                self.skipTest(f"directory symlinks unavailable: {exc}")
-
-            paths, safe = self.gate._safe_file_paths(
-                candidate, ["alias/nested.txt"]
-            )
-            self.assertFalse(safe)
-            self.assertEqual([], paths)
-
-    def test_release_identity_includes_publication_date(self):
-        with tempfile.TemporaryDirectory() as directory:
-            candidate = Path(directory) / "release"
-            shutil.copytree(ROOT, candidate)
-            metadata_path = candidate / ".zenodo.json"
-            metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
-            metadata["publication_date"] = "1900-01-01"
-            metadata_path.write_text(
-                json.dumps(metadata, indent=2) + "\n", encoding="utf-8"
-            )
-            subprocess.run(
-                [sys.executable, "tools/update_checksums.py", "--write"],
-                cwd=candidate,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            report = self.gate.build_publication_report(candidate)
-            checks = {check["code"]: check["status"] for check in report["checks"]}
-            self.assertEqual("blocked", report["status"])
-            self.assertEqual("fail", checks["release_identity"])
-            self.assertEqual("pass", checks["release_checksums"])
-
-    def test_non_object_identity_documents_block_without_throwing(self):
-        identity_files = (
-            ".zenodo.json",
-            "codemeta.json",
-            "schema/payment-statement-audit.schema.json",
-            "examples/payment-statement-audit-example.json",
-        )
-        for filename in identity_files:
-            with self.subTest(filename=filename):
-                with tempfile.TemporaryDirectory() as directory:
-                    candidate = Path(directory) / "release"
-                    shutil.copytree(ROOT, candidate)
-                    (candidate / filename).write_text("[]\n", encoding="utf-8")
-                    subprocess.run(
-                        [sys.executable, "tools/update_checksums.py", "--write"],
-                        cwd=candidate,
-                        check=True,
-                        capture_output=True,
-                        text=True,
-                        encoding="utf-8",
-                    )
-
-                    report = self.gate.build_publication_report(candidate)
-                    checks = {
-                        check["code"]: check["status"] for check in report["checks"]
-                    }
-                    self.assertEqual("blocked", report["status"])
-                    self.assertEqual("fail", checks["release_identity"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_release_assets.py

@@ -1,275 +0,0 @@
-import hashlib
-import json
-import re
-import subprocess
-import unittest
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[1]
-TITLE = "Lifted Payments Payment Statement Audit Model"
-CANONICAL_URL = "https://liftedpayments.com/payment-processing-statement-audit/"
-REPOSITORY_URL = "https://github.com/Lifted-Holdings/payment-processing-resources"
-VERSION = "1.1.3"
-SCHEMA_VERSION = "1.1.0"
-RELEASE_DATE = "2026-08-02"
-DOI = "10.5281/zenodo.21764642"
-DOI_URL = f"https://doi.org/{DOI}"
-CONCEPT_DOI_URL = "https://doi.org/10.5281/zenodo.21761714"
-RELEASE_URL = (
-    "https://github.com/Lifted-Holdings/payment-processing-resources/"
-    "releases/tag/v1.1.3"
-)
-HUGGING_FACE_REPO_ID = "Liftedholdings/payment-statement-audit-model"
-KAGGLE_DATASET_ID = "liftedpayments/payment-statement-audit-model"
-RUNTIME_ONLY_DIRECTORIES = {
-    ".git",
-    ".mypy_cache",
-    ".pytest_cache",
-    ".ruff_cache",
-    ".venv",
-    "__pycache__",
-    "venv",
-}
-
-
-def git_metadata_is_available():
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--is-inside-work-tree"],
-            cwd=ROOT,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-    except OSError:
-        return False
-    return result.returncode == 0 and result.stdout.strip() == "true"
-
-
-def portable_release_inventory():
-    files = set()
-    for path in ROOT.rglob("*"):
-        relative = path.relative_to(ROOT)
-        if any(part in RUNTIME_ONLY_DIRECTORIES for part in relative.parts):
-            continue
-        if path.is_file() or path.is_symlink():
-            files.add(relative.as_posix())
-    return files
-
-
-class ReleaseAssetTests(unittest.TestCase):
-    def test_zenodo_metadata_is_complete_and_consistent(self):
-        metadata = json.loads((ROOT / ".zenodo.json").read_text(encoding="utf-8"))
-
-        self.assertEqual(metadata["title"], TITLE)
-        self.assertEqual(metadata["version"], VERSION)
-        self.assertEqual(metadata["publication_date"], RELEASE_DATE)
-        self.assertEqual(metadata["upload_type"], "dataset")
-        self.assertEqual(metadata["access_right"], "open")
-        self.assertEqual(metadata["license"], "cc-by-4.0")
-        self.assertEqual(metadata["language"], "eng")
-        self.assertIn(
-            {"name": "Lifted Payments", "affiliation": "Lifted Holdings"},
-            metadata["creators"],
-        )
-        self.assertGreaterEqual(len(metadata["keywords"]), 6)
-
-        manifest = json.loads(
-            (ROOT / "RELEASE-MANIFEST.json").read_text(encoding="utf-8")
-        )
-        self.assertEqual(RELEASE_DATE, manifest["release_date"])
-
-        related = {
-            (item["identifier"], item["relation"])
-            for item in metadata["related_identifiers"]
-        }
-        self.assertIn((CANONICAL_URL, "isDocumentedBy"), related)
-        self.assertIn((RELEASE_URL, "isSourceOf"), related)
-
-    def test_codemeta_describes_the_same_dataset(self):
-        metadata = json.loads((ROOT / "codemeta.json").read_text(encoding="utf-8"))
-
-        self.assertEqual(metadata["@type"], "Dataset")
-        self.assertEqual(metadata["name"], TITLE)
-        self.assertEqual(metadata["version"], VERSION)
-        self.assertEqual(metadata["datePublished"], RELEASE_DATE)
-        self.assertEqual(metadata["license"], "https://creativecommons.org/licenses/by/4.0/")
-        self.assertEqual(metadata["url"], CANONICAL_URL)
-        self.assertEqual(metadata["codeRepository"], REPOSITORY_URL)
-        self.assertEqual(metadata["creator"]["name"], "Lifted Payments")
-        self.assertEqual(metadata["publisher"]["name"], "Lifted Holdings")
-        self.assertTrue(metadata["isAccessibleForFree"])
-        self.assertEqual(metadata["identifier"], DOI_URL)
-        self.assertIn(DOI_URL, metadata["sameAs"])
-
-    def test_citation_metadata_matches_release(self):
-        citation = (ROOT / "CITATION.cff").read_text(encoding="utf-8")
-
-        self.assertRegex(citation, rf'(?m)^title: "{re.escape(TITLE)}"$')
-        self.assertRegex(citation, rf"(?m)^version: {re.escape(VERSION)}$")
-        self.assertRegex(citation, rf"(?m)^date-released: {re.escape(RELEASE_DATE)}$")
-        self.assertIn(f'url: "{CANONICAL_URL}"', citation)
-        self.assertIn(f'repository-code: "{REPOSITORY_URL}"', citation)
-        self.assertRegex(citation, r"(?m)^type: dataset$")
-        self.assertRegex(citation, r"(?m)^license: CC-BY-4\.0$")
-        self.assertRegex(citation, rf'(?m)^doi: "{re.escape(DOI)}"$')
-
-    def test_schema_and_synthetic_example_are_internally_consistent(self):
-        schema = json.loads(
-            (ROOT / "schema/payment-statement-audit.schema.json").read_text(
-                encoding="utf-8"
-            )
-        )
-        example = json.loads(
-            (ROOT / "examples/payment-statement-audit-example.json").read_text(
-                encoding="utf-8"
-            )
-        )
-
-        for field in schema["required"]:
-            self.assertIn(field, example)
-        self.assertEqual(schema["$schema"], "https://json-schema.org/draft/2020-12/schema")
-        self.assertAlmostEqual(
-            example["effective_rate"],
-            example["total_processing_fees"] / example["card_volume"],
-            places=6,
-        )
-        self.assertTrue(
-            any("synthetic" in note.lower() for note in example["review_notes"])
-        )
-        self.assertEqual(SCHEMA_VERSION, example["schema_version"])
-
-    def test_checksums_cover_every_declared_release_file(self):
-        manifest = json.loads(
-            (ROOT / "RELEASE-MANIFEST.json").read_text(encoding="utf-8")
-        )
-        expected_files = set(manifest["files"]) - {"checksums.txt"}
-        checksum_lines = (ROOT / "checksums.txt").read_text(encoding="utf-8").splitlines()
-        checksums = {}
-        for line in checksum_lines:
-            digest, filename = re.split(r"\s+", line.strip(), maxsplit=1)
-            checksums[filename] = digest
-
-        self.assertEqual(set(checksums), expected_files)
-        for filename, expected_digest in checksums.items():
-            actual_digest = hashlib.sha256((ROOT / filename).read_bytes()).hexdigest()
-            self.assertEqual(expected_digest, actual_digest)
-
-    def test_release_manifest_covers_every_repository_asset(self):
-        manifest = json.loads(
-            (ROOT / "RELEASE-MANIFEST.json").read_text(encoding="utf-8")
-        )
-        if git_metadata_is_available():
-            result = subprocess.run(
-                [
-                    "git",
-                    "ls-files",
-                    "--cached",
-                    "--others",
-                    "--exclude-standard",
-                ],
-                cwd=ROOT,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-            repository_files = {
-                line.replace("\\", "/")
-                for line in result.stdout.splitlines()
-                if line
-            }
-        else:
-            repository_files = portable_release_inventory()
-        self.assertEqual(repository_files, set(manifest["files"]))
-
-    def test_release_files_are_pinned_to_lf_by_git(self):
-        manifest = json.loads(
-            (ROOT / "RELEASE-MANIFEST.json").read_text(encoding="utf-8")
-        )
-        release_files = manifest["files"]
-        if git_metadata_is_available():
-            result = subprocess.run(
-                ["git", "check-attr", "eol", "--", *release_files],
-                cwd=ROOT,
-                check=True,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-            )
-
-            observed = {
-                line.split(": ", maxsplit=2)[0]: line.split(": ", maxsplit=2)[2]
-                for line in result.stdout.splitlines()
-            }
-            self.assertEqual(observed, {filename: "lf" for filename in release_files})
-        else:
-            for filename in release_files:
-                with self.subTest(filename=filename):
-                    self.assertNotIn(b"\r\n", (ROOT / filename).read_bytes())
-
-    def test_readme_presents_the_versioned_release_and_canonical_citation(self):
-        readme = (ROOT / "README.md").read_text(encoding="utf-8")
-
-        self.assertIn("## Versioned release", readme)
-        self.assertIn("v1.1.3", readme)
-        self.assertIn("August 2, 2026", readme)
-        self.assertIn(CANONICAL_URL, readme)
-        self.assertIn("CITATION.cff", readme)
-        self.assertIn(DOI_URL, readme)
-        self.assertNotIn("DOI_PLACEHOLDER", readme)
-
-    def test_ai_summary_exposes_the_persistent_identifier(self):
-        llms = (ROOT / "llms.txt").read_text(encoding="utf-8")
-
-        self.assertIn(DOI_URL, llms)
-        self.assertIn(
-            "https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.3",
-            llms,
-        )
-
-    def test_huggingface_dataset_card_matches_release_identity(self):
-        card_path = ROOT / "distribution/huggingface/README.md"
-        self.assertTrue(card_path.is_file(), "Hugging Face dataset card is missing")
-        card = card_path.read_text(encoding="utf-8")
-        self.assertTrue(card.startswith("---\n"))
-        _, frontmatter, body = card.split("---", maxsplit=2)
-
-        self.assertRegex(frontmatter, r"(?m)^license: cc-by-4\.0$")
-        self.assertRegex(
-            frontmatter, rf'(?m)^pretty_name: "{re.escape(TITLE)}"$'
-        )
-        self.assertRegex(frontmatter, r"(?m)^- en$")
-        for tag in ("tabular", "finance", "payments", "merchant-services"):
-            self.assertRegex(frontmatter, rf"(?m)^- {re.escape(tag)}$")
-
-        for identity_url in (CANONICAL_URL, DOI_URL, CONCEPT_DOI_URL, RELEASE_URL):
-            self.assertIn(identity_url, body)
-        self.assertIn(VERSION, body)
-        self.assertIn("synthetic", body.lower())
-        self.assertIn("no real merchant", body.lower())
-
-    def test_kaggle_distribution_metadata_matches_release_identity(self):
-        metadata_path = ROOT / "distribution/kaggle/dataset-metadata.json"
-        description_path = ROOT / "distribution/kaggle/README.md"
-        self.assertTrue(metadata_path.is_file(), "Kaggle metadata is missing")
-        self.assertTrue(description_path.is_file(), "Kaggle description is missing")
-        metadata = json.loads(
-            metadata_path.read_text(encoding="utf-8")
-        )
-        description = description_path.read_text(encoding="utf-8")
-
-        self.assertEqual(metadata["id"], KAGGLE_DATASET_ID)
-        self.assertEqual(metadata["title"], TITLE)
-        self.assertIn("merchant statement", metadata["subtitle"].lower())
-        self.assertIn({"name": "CC-BY-4.0"}, metadata["licenses"])
-        for identity_url in (CANONICAL_URL, DOI_URL, CONCEPT_DOI_URL, RELEASE_URL):
-            self.assertIn(identity_url, description)
-        self.assertIn(VERSION, description)
-        self.assertIn("synthetic", description.lower())
-        self.assertIn("no real merchant", description.lower())
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_release_provenance.py

@@ -1,189 +0,0 @@
-import importlib.util
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[1]
-PROVENANCE_PATH = ROOT / "tools/release_provenance.py"
-
-
-def load_module(path: Path, name: str):
-    spec = importlib.util.spec_from_file_location(name, path)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"Unable to load {name}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def run_git(cwd: Path, *args: str) -> str:
-    result = subprocess.run(
-        ["git", *args],
-        cwd=cwd,
-        check=True,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    return result.stdout.strip()
-
-
-class RepositoryProvenanceTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not PROVENANCE_PATH.is_file():
-            raise AssertionError("tools/release_provenance.py is required")
-        cls.provenance = load_module(PROVENANCE_PATH, "release_provenance")
-
-    def setUp(self):
-        self.temporary_directory = tempfile.TemporaryDirectory()
-        self.base = Path(self.temporary_directory.name)
-
-    def tearDown(self):
-        self.temporary_directory.cleanup()
-
-    def create_remote(self) -> Path:
-        remote = self.base / "remote.git"
-        seed = self.base / "seed"
-        run_git(self.base, "init", "--bare", str(remote))
-        run_git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
-        run_git(self.base, "init", "-b", "main", str(seed))
-        run_git(seed, "config", "user.name", "Release Test")
-        run_git(seed, "config", "user.email", "release-test@example.invalid")
-        run_git(seed, "config", "core.autocrlf", "false")
-        (seed / "README.md").write_text("release\n", encoding="utf-8")
-        run_git(seed, "add", "README.md")
-        run_git(seed, "commit", "-m", "initial release")
-        run_git(seed, "tag", "-a", "v1.1.2", "-m", "v1.1.2")
-        run_git(seed, "remote", "add", "origin", str(remote))
-        run_git(seed, "push", "-u", "origin", "main")
-        run_git(seed, "push", "origin", "v1.1.2")
-        return remote
-
-    def clone_remote(self, remote: Path, *, no_tags: bool = False) -> Path:
-        clone = self.base / ("clone-no-tags" if no_tags else "clone")
-        args = ["-c", "core.autocrlf=false", "clone"]
-        if no_tags:
-            args.append("--no-tags")
-        args.extend([str(remote), str(clone)])
-        run_git(self.base, *args)
-        run_git(clone, "config", "user.name", "Release Test")
-        run_git(clone, "config", "user.email", "release-test@example.invalid")
-        run_git(clone, "config", "core.autocrlf", "false")
-        return clone
-
-    def inspect(self, root: Path, version: str, remote: Path):
-        return self.provenance.inspect_repository(
-            root,
-            version,
-            files=("README.md",),
-            expected_origin=str(remote.resolve()),
-        )
-
-    def test_tagless_release_cannot_be_publication_ready(self):
-        candidate = self.base / "release"
-        candidate.mkdir()
-        (candidate / "README.md").write_text("altered release\n", encoding="utf-8")
-
-        result = self.provenance.inspect_repository(
-            candidate,
-            "1.1.2",
-            files=("README.md",),
-            expected_origin="https://github.com/Lifted-Holdings/payment-processing-resources",
-        )
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("git_metadata_missing", result.failure_codes)
-
-    def test_existing_remote_tag_missing_locally_is_not_treated_as_new(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote, no_tags=True)
-
-        result = self.inspect(clone, "1.1.2", remote)
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("local_release_tag_missing", result.failure_codes)
-
-    def test_dirty_tracked_candidate_is_blocked(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote)
-        (clone / "README.md").write_text("dirty\n", encoding="utf-8")
-
-        result = self.inspect(clone, "1.1.2", remote)
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("working_tree_dirty", result.failure_codes)
-
-    def test_untracked_candidate_asset_is_blocked(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote)
-        (clone / "undeclared.txt").write_text("untracked\n", encoding="utf-8")
-
-        result = self.inspect(clone, "1.1.2", remote)
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("working_tree_dirty", result.failure_codes)
-
-    def test_local_and_remote_release_tag_mismatch_is_blocked(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote)
-        (clone / "README.md").write_text("second commit\n", encoding="utf-8")
-        run_git(clone, "add", "README.md")
-        run_git(clone, "commit", "-m", "second commit")
-        run_git(clone, "tag", "-f", "v1.1.2")
-
-        result = self.inspect(clone, "1.1.2", remote)
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("remote_tag_mismatch", result.failure_codes)
-
-    def test_lower_untagged_version_is_blocked_by_highest_remote_release(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote, no_tags=True)
-
-        result = self.inspect(clone, "1.1.1", remote)
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("version_not_monotonic", result.failure_codes)
-
-    def test_newer_untagged_version_can_pass_repository_provenance(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote, no_tags=True)
-
-        result = self.inspect(clone, "1.1.3", remote)
-
-        self.assertTrue(result.publication_ready, result.failure_codes)
-        self.assertEqual("new", result.release_state)
-        self.assertEqual((), result.failure_codes)
-
-    def test_untrusted_origin_is_blocked(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote)
-
-        result = self.provenance.inspect_repository(
-            clone,
-            "1.1.2",
-            files=("README.md",),
-            expected_origin="https://github.com/Lifted-Holdings/payment-processing-resources",
-        )
-
-        self.assertFalse(result.publication_ready)
-        self.assertIn("origin_untrusted", result.failure_codes)
-
-    def test_exact_annotated_release_tag_and_clean_tree_pass(self):
-        remote = self.create_remote()
-        clone = self.clone_remote(remote)
-
-        result = self.inspect(clone, "1.1.2", remote)
-
-        self.assertTrue(result.publication_ready, result.failure_codes)
-        self.assertEqual("tagged", result.release_state)
-        self.assertRegex(result.head_commit or "", r"^[0-9a-f]{40}$")
-
-
-if __name__ == "__main__":
-    unittest.main()