@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/publisher-agreement.js

@@ -0,0 +1,274 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The marketplace publisher agreement, and whether an org has accepted the
+ * current one (AGL-1077).
+ *
+ * Deliberately NOT the per-version attestation (AGL-969). An attestation is
+ * a statement about *specific bytes* and re-asks on every republish, because
+ * the bytes changed. This is about the *relationship*: what we may do with a
+ * listing, what the publisher warrants, indemnity, takedown, payouts, what
+ * survives termination. It is accepted once, by an org, and re-asked only
+ * when we change it.
+ *
+ * Shared like the attestation model is, and for the same reason: the publish
+ * route enforces it, the profile page collects it, and the review page shows
+ * staff which terms a publisher is actually under. Three copies of a version
+ * string would drift, and a drifted version is one that either re-asks
+ * forever or never re-asks at all.
+ */ import { LEGAL_ORIGIN, isPublishedLegalUrl } from "./published-legal-pages.js";
+/**
+ * The version of the agreement currently in force.
+ *
+ * Matches the `Agreement version` header of the document itself, which is now
+ * besigner content at {@link PUBLISHER_AGREEMENT_URL} rather than a repo file
+ * (same practice as the Terms of Service). Bump this **only** when the
+ * substance changes in a way a publisher should re-read — a typo fix is not a
+ * bump. Bumping it stops every publisher at their next publish until they
+ * accept again.
+ *
+ * Moved off `2026-07-28.1` on 2026-08-14 (AGL-1674). That string named the
+ * July draft, which was never published and whose §8 said the publisher is the
+ * seller of record. The published text says the opposite — Aglyn processes the
+ * sale and remits transaction tax — so it is a different document in
+ * substance, not a reissue, and re-asking is the point rather than a cost.
+ *
+ * Moved to `2026-08-18.1` on 2026-08-18 (AGL-1840 + AGL-1661). Two body-text
+ * changes: §1 now says "the Aglyn marketplace" (the AGL-975 rename, and the
+ * reason this snapshot must NOT need the AGL-975 naming-guard exemption that
+ * the `2026-08-14.1` one still carries), and §1's cross-reference to
+ * the "End User Licence Agreement"
+ * becomes "License" to match the document that agreement actually is, which
+ * was renamed on the same day.
+ *
+ * ⚠️ Read against the "a typo fix is not a bump" rule above, both edits are
+ * closer to a typo than to substance, and the tension is real. The bump was
+ * taken anyway on the decision (2026-08-18), for a reason the rule does not
+ * cover: the served page changed, so keeping `2026-08-14.1` would leave the
+ * pin below asserting a hash for text nobody is shown any more — a FALSE
+ * RECORD, which is the exact failure the pin exists to detect. The choice is
+ * therefore between a bump and a broken pin, not between a bump and nothing.
+ *
+ * ## 2026-08-22 — the page changed and this string DELIBERATELY did not
+ *
+ * Three clauses were added on 2026-08-22 (§3(h) listing conduct, §8.6 sales
+ * through the Marketplace, §13.6 marks) and the pin below moved with them, but
+ * `2026-08-18.1` stayed. That is not the third option the paragraph above says
+ * does not exist — it is the same choice with one input changed. A bump exists
+ * to re-ask publishers who accepted the OLD text; production holds exactly one
+ * acceptance record and it is the own, so there is nobody to re-ask and the
+ * bump would buy nothing. the decision, 2026-08-22.
+ *
+ * The pin still had to move, for precisely the reason given above: the served
+ * bytes changed, so leaving the old hash here would assert a document nobody
+ * is shown. Version unchanged + pin re-captured is coherent ONLY while the
+ * acceptance set is empty. The first real publisher acceptance ends that, and
+ * from then on any body-text change costs a bump — see the same rule in
+ * `apps/console/constants/legal-documents.ts`, where the clickwrap snapshots
+ * collapsed back to `v1` on the identical argument.
+ *
+ * ## 2026-08-24 — `2026-08-24.1`, and why this one CANNOT be folded (AGL-1956)
+ *
+ * §13.3 changed twice in one sentence. The venue moved from Williamson County
+ * to TRAVIS County (decided) — Williamson entered from the former
+ * Jarrell residential address, while every published Aglyn address is 5900
+ * Balcones Dr STE 100, Austin, TX 78731, which is Travis. And the clause cited
+ * "Terms of Service Section 19" for governing law and venue when those live at
+ * §18.6; §19 is General. A wrong cross-reference in a forum-selection clause is
+ * the kind of defect that gets argued about, so it was corrected in the same
+ * pass.
+ *
+ * Unlike 2026-08-22, this one takes the bump rather than only re-pinning, and
+ * the deciding reason is mechanical rather than editorial: THIS VERSION STRING
+ * IS PUBLISHED IN THE DOCUMENT. The page at {@link PUBLISHER_AGREEMENT_URL}
+ * serves `Agreement version: 2026-08-24.1` in its own second line, so the
+ * capture below contains it, and `publisher-agreement-version.spec.ts` asserts
+ * the snapshot contains `Agreement version: ${PUBLISHER_AGREEMENT_VERSION}`.
+ * Holding the constant at `2026-08-18.1` against that text would need the page
+ * republished to say so, and would otherwise record a publisher as having
+ * accepted `2026-08-18.1` while naming bytes that call themselves
+ * `2026-08-24.1`. That is a false record of exactly the shape the pin exists
+ * to prevent.
+ *
+ * ⚠️ THIS IS THE ONE PLACE THE CLICKWRAP ARGUMENT DOES NOT REACH. The signup
+ * clickwrap folded its 2026-08-24 corrections into `v1` and did not bump
+ * (`apps/console/constants/legal-documents.ts`) — decided: no v2
+ * before launch. That works there because `v1` is a REPO-SIDE label: the
+ * published Terms carry a "Last updated" date and no version string at all, so
+ * the label can stay still while the text moves. Here the label is part of the
+ * document a publisher reads. The two schemes are not the same kind of thing
+ * and must not be reasoned about as one — that difference is the whole content
+ * of this paragraph.
+ *
+ * On the merits it would have been a bump anyway: a forum-selection clause is
+ * substance, not a typo — it names the court a publisher would have to travel
+ * to. The 2026-08-22 cost argument is unchanged and still cheap, production
+ * holding exactly one acceptance record which is the own.
+ *
+ * §8.1 and §8.3 are UNTOUCHED and were already correct: they have said Aglyn is
+ * merchant of record and determines, collects and remits transaction tax since
+ * 2026-08-14. The Terms of Service moved TO them in this pass (new ToS §10.7),
+ * not the other way around.
+ */ export const PUBLISHER_AGREEMENT_VERSION = '2026-08-24.1';
+export const PUBLISHER_AGREEMENT_TITLE = 'Marketplace Publisher Agreement';
+/**
+ * The snapshot pin for the version above (AGL-1678).
+ *
+ * A version string is a label we control and can reuse, so on its own it
+ * proves nothing about what a publisher actually read. These two values pin
+ * the archived snapshot at
+ * `legal/publisher-agreement/{PUBLISHER_AGREEMENT_VERSION}/marketplace-publisher-agreement.txt`
+ * (beside this module), captured FROM THE LIVE PAGE after publication — the
+ * same publication-first machinery as the signup clickwrap
+ * (`apps/console/constants/legal-documents.ts`, AGL-1497), and deliberately a
+ * PARALLEL manifest rather than an entry in `LEGAL_DOCUMENTS`: ToS §19.1 makes
+ * that set the entire signup agreement, and the publisher agreement is
+ * deliberately not part of it. Mixing them would widen what a signup
+ * acceptance covers.
+ *
+ * Both values go onto every acceptance record, so a record is self-contained
+ * evidence of content and later tampering with the archive is detectable
+ * rather than invisible. `publisher-agreement-version.spec.ts` re-hashes the
+ * snapshot, so one version string can never come to mean two different
+ * documents.
+ *
+ * Capture method (proven byte-for-byte against the clickwrap v4 hashes before
+ * this snapshot was taken): fetch the live page, walk its HTML text nodes
+ * skipping script/style, trim each, drop empties, take the document's content
+ * block (first line `Last updated: …` through its closing `© …` line,
+ * excluding site chrome and the table of contents), join with `\n`, and end
+ * with a trailing newline. UTF-8 throughout.
+ *
+ * TO PUBLISH A CHANGE: publish the besigner edit first, confirm the live page
+ * serves it, capture a new snapshot under the new version's directory, then
+ * bump `PUBLISHER_AGREEMENT_VERSION` and these two values together. Never
+ * hand-write a snapshot: it is evidence of what a publisher was shown, and a
+ * snapshot of unpublished text is a false record.
+ */ export const PUBLISHER_AGREEMENT_SHA256 = '2df6e940f037b4630e53c8f63bad8604ef4bf370374b89afcd4ea7f9fe8e8d63';
+/** Byte length of the same snapshot — a cheap second check on the content. */ export const PUBLISHER_AGREEMENT_BYTES = 13730;
+/**
+ * Canonical document, on the operator's legal origin beside the other terms.
+ *
+ * Built from `LEGAL_ORIGIN` (AGL-2196), which this module already depends on:
+ * `publisherAgreementIsPublished` below calls `isPublishedLegalUrl`, and that
+ * accepts ONLY `LEGAL_ORIGIN`. So the gate was operator-aware while the link
+ * it gates was a bare `aglyn.com` literal — meaning on a self-host install
+ * with `NEXT_PUBLIC_OPERATOR_LEGAL_ORIGIN` set, the gate rejected the very URL
+ * this file handed it, and every publisher was blocked from accepting. One
+ * origin for both closes that, and leaves Aglyn's own URL byte-identical.
+ */ export const PUBLISHER_AGREEMENT_URL = `${LEGAL_ORIGIN}/legal/marketplace-publisher-agreement`;
+/**
+ * Whether that document can actually be read (AGL-1660).
+ *
+ * It could not, from the day this gate shipped until the day this check did:
+ * the URL above 404ed, and the console still rendered it as "Read the full
+ * Marketplace Publisher Agreement" above an Accept button. An acceptance
+ * collected that way is a signature on a blank page — the same
+ * publication-first principle the clickwrap snapshots are built on, failing in
+ * the one place the text was never published at all.
+ *
+ * Derived, not a second flag: it reads `PUBLISHED_LEGAL_PATHS`, so the ONE
+ * edit that adds the path when the page goes live is what re-opens acceptance
+ * everywhere. There is no boolean to forget to flip, and no way for the link
+ * and the gate to disagree.
+ */ export function publisherAgreementIsPublished(url = PUBLISHER_AGREEMENT_URL) {
+    return isPublishedLegalUrl(url);
+}
+/**
+ * What a publisher is told while the document has no page.
+ *
+ * Deliberately not "try again later" — it names the reason, because the fix is
+ * ours and the publisher can do nothing about it. It must never read as though
+ * accepting is something they merely have not got round to.
+ */ export const PUBLISHER_AGREEMENT_UNAVAILABLE_NOTICE = `The ${PUBLISHER_AGREEMENT_TITLE} is not published yet, so there is ` + 'nothing here for you to read — and we will not ask you to agree to a ' + 'document we have not shown you. Acceptance is paused until it is ' + 'available, which also means marketplace publishing is paused. Nothing is ' + 'required of you in the meantime.';
+/**
+ * What the agreement actually commits a publisher to.
+ *
+ * Shown above the accept control. A link alone is the pattern that produces
+ * agreements nobody has read; these are the terms most likely to surprise
+ * someone later, in the words they would need at that moment. They summarise
+ * the document — they are not it, and the copy says so.
+ */ export const PUBLISHER_AGREEMENT_POINTS = [
+    {
+        id: 'hosting-license',
+        label: 'We may host, verify and distribute what you publish',
+        detail: 'Including keeping an immutable copy of every version, inspecting its code, and showing your listing content in the marketplace and console.'
+    },
+    {
+        id: 'warranties',
+        label: 'You warrant each version as you publish it',
+        detail: 'That you have the right to publish it, that its license is accurate and compatible, that it carries no malware or hidden telemetry, and that its documentation describes what it does with data.'
+    },
+    {
+        id: 'immutable',
+        label: 'You cannot recall code that is already installed',
+        detail: 'Installs pin an exact version and hash. A mistake ships until an installer chooses to upgrade — publishing a new version is the only remedy you have.'
+    },
+    {
+        id: 'revocation',
+        label: 'We can disable a version everywhere, without notice',
+        detail: 'If a version looks like a security, legal or privacy risk we stop it on every site running it, and tell you afterwards. Operating a platform that executes other people’s code requires this.'
+    },
+    {
+        id: 'review',
+        label: 'Review is a safety screen, not an endorsement',
+        detail: 'Approval is not an audit and not a guarantee your plugin works. We may decline, delist or unsign anything, for reasons that may have nothing to do with your code.'
+    },
+    {
+        id: 'payouts',
+        label: 'On paid listings we process the sale and take a fee',
+        detail: 'We process the purchase and pay your share into your own Stripe Connect account, less a platform fee that may change. We collect and remit sales tax on Marketplace sales; refunds, chargebacks and support on your Artifacts are yours.'
+    },
+    {
+        id: 'indemnity',
+        label: 'You indemnify us for claims arising from what you publish',
+        detail: 'Including infringement claims and disputes with the organizations that install it.'
+    }
+];
+export function publisherAgreementState(acceptance, currentVersion = PUBLISHER_AGREEMENT_VERSION) {
+    const accepted = acceptance == null ? void 0 : acceptance.version;
+    if (typeof accepted !== 'string' || !accepted.trim()) return 'none';
+    return accepted === currentVersion ? 'current' : 'outdated';
+}
+/**
+ * Whether a publish may proceed.
+ *
+ * An older acceptance is NOT carried forward. Whoever publishes next reads
+ * the changed agreement and accepts it, or does not publish — silently
+ * inheriting an acceptance across a rewrite is precisely what makes the
+ * record worthless.
+ */ export function hasCurrentPublisherAgreement(acceptance, currentVersion = PUBLISHER_AGREEMENT_VERSION) {
+    return publisherAgreementState(acceptance, currentVersion) === 'current';
+}
+export function publisherAgreementPresentation(state, published = publisherAgreementIsPublished()) {
+    return {
+        documentUrl: published ? PUBLISHER_AGREEMENT_URL : null,
+        // Already current is not "cannot accept because unpublished" — it is
+        // nothing left to do, and the panel says so separately.
+        canAccept: published && state !== 'current',
+        unavailableNotice: published ? null : PUBLISHER_AGREEMENT_UNAVAILABLE_NOTICE
+    };
+}
+/** The refusal a publisher sees, saying which of the two problems it is. */ export function publisherAgreementRefusal(state, published = publisherAgreementIsPublished()) {
+    // Sending someone to a control we have disabled is worse than saying
+    // nothing: they go, find no button, and conclude the console is broken.
+    if (!published) {
+        return `The ${PUBLISHER_AGREEMENT_TITLE} is not published yet, so it cannot ` + 'be accepted and publishing is paused for everyone. This is on us, not ' + 'on your organization.';
+    }
+    return state === 'outdated' ? `The ${PUBLISHER_AGREEMENT_TITLE} has changed since your organization ` + 'accepted it. Review and accept the current version in Marketplace → ' + 'Publisher Profile, then publish.' : `Your organization has not accepted the ${PUBLISHER_AGREEMENT_TITLE}. ` + 'Accept it in Marketplace → Publisher Profile, then publish.';
+}
+
+//# sourceMappingURL=publisher-agreement.js.map

package/src/lib/app-utils/publisher-agreement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/publisher-agreement.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The marketplace publisher agreement, and whether an org has accepted the\n * current one (AGL-1077).\n *\n * Deliberately NOT the per-version attestation (AGL-969). An attestation is\n * a statement about *specific bytes* and re-asks on every republish, because\n * the bytes changed. This is about the *relationship*: what we may do with a\n * listing, what the publisher warrants, indemnity, takedown, payouts, what\n * survives termination. It is accepted once, by an org, and re-asked only\n * when we change it.\n *\n * Shared like the attestation model is, and for the same reason: the publish\n * route enforces it, the profile page collects it, and the review page shows\n * staff which terms a publisher is actually under. Three copies of a version\n * string would drift, and a drifted version is one that either re-asks\n * forever or never re-asks at all.\n */\n\nimport { LEGAL_ORIGIN, isPublishedLegalUrl } from './published-legal-pages'\n\n/**\n * The version of the agreement currently in force.\n *\n * Matches the `Agreement version` header of the document itself, which is now\n * besigner content at {@link PUBLISHER_AGREEMENT_URL} rather than a repo file\n * (same practice as the Terms of Service). Bump this **only** when the\n * substance changes in a way a publisher should re-read — a typo fix is not a\n * bump. Bumping it stops every publisher at their next publish until they\n * accept again.\n *\n * Moved off `2026-07-28.1` on 2026-08-14 (AGL-1674). That string named the\n * July draft, which was never published and whose §8 said the publisher is the\n * seller of record. The published text says the opposite — Aglyn processes the\n * sale and remits transaction tax — so it is a different document in\n * substance, not a reissue, and re-asking is the point rather than a cost.\n *\n * Moved to `2026-08-18.1` on 2026-08-18 (AGL-1840 + AGL-1661). Two body-text\n * changes: §1 now says \"the Aglyn marketplace\" (the AGL-975 rename, and the\n * reason this snapshot must NOT need the AGL-975 naming-guard exemption that\n * the `2026-08-14.1` one still carries), and §1's cross-reference to\n * the \"End User Licence Agreement\"\n * becomes \"License\" to match the document that agreement actually is, which\n * was renamed on the same day.\n *\n * ⚠️ Read against the \"a typo fix is not a bump\" rule above, both edits are\n * closer to a typo than to substance, and the tension is real. The bump was\n * taken anyway on the decision (2026-08-18), for a reason the rule does not\n * cover: the served page changed, so keeping `2026-08-14.1` would leave the\n * pin below asserting a hash for text nobody is shown any more — a FALSE\n * RECORD, which is the exact failure the pin exists to detect. The choice is\n * therefore between a bump and a broken pin, not between a bump and nothing.\n *\n * ## 2026-08-22 — the page changed and this string DELIBERATELY did not\n *\n * Three clauses were added on 2026-08-22 (§3(h) listing conduct, §8.6 sales\n * through the Marketplace, §13.6 marks) and the pin below moved with them, but\n * `2026-08-18.1` stayed. That is not the third option the paragraph above says\n * does not exist — it is the same choice with one input changed. A bump exists\n * to re-ask publishers who accepted the OLD text; production holds exactly one\n * acceptance record and it is the own, so there is nobody to re-ask and the\n * bump would buy nothing. the decision, 2026-08-22.\n *\n * The pin still had to move, for precisely the reason given above: the served\n * bytes changed, so leaving the old hash here would assert a document nobody\n * is shown. Version unchanged + pin re-captured is coherent ONLY while the\n * acceptance set is empty. The first real publisher acceptance ends that, and\n * from then on any body-text change costs a bump — see the same rule in\n * `apps/console/constants/legal-documents.ts`, where the clickwrap snapshots\n * collapsed back to `v1` on the identical argument.\n *\n * ## 2026-08-24 — `2026-08-24.1`, and why this one CANNOT be folded (AGL-1956)\n *\n * §13.3 changed twice in one sentence. The venue moved from Williamson County\n * to TRAVIS County (decided) — Williamson entered from the former\n * Jarrell residential address, while every published Aglyn address is 5900\n * Balcones Dr STE 100, Austin, TX 78731, which is Travis. And the clause cited\n * \"Terms of Service Section 19\" for governing law and venue when those live at\n * §18.6; §19 is General. A wrong cross-reference in a forum-selection clause is\n * the kind of defect that gets argued about, so it was corrected in the same\n * pass.\n *\n * Unlike 2026-08-22, this one takes the bump rather than only re-pinning, and\n * the deciding reason is mechanical rather than editorial: THIS VERSION STRING\n * IS PUBLISHED IN THE DOCUMENT. The page at {@link PUBLISHER_AGREEMENT_URL}\n * serves `Agreement version: 2026-08-24.1` in its own second line, so the\n * capture below contains it, and `publisher-agreement-version.spec.ts` asserts\n * the snapshot contains `Agreement version: ${PUBLISHER_AGREEMENT_VERSION}`.\n * Holding the constant at `2026-08-18.1` against that text would need the page\n * republished to say so, and would otherwise record a publisher as having\n * accepted `2026-08-18.1` while naming bytes that call themselves\n * `2026-08-24.1`. That is a false record of exactly the shape the pin exists\n * to prevent.\n *\n * ⚠️ THIS IS THE ONE PLACE THE CLICKWRAP ARGUMENT DOES NOT REACH. The signup\n * clickwrap folded its 2026-08-24 corrections into `v1` and did not bump\n * (`apps/console/constants/legal-documents.ts`) — decided: no v2\n * before launch. That works there because `v1` is a REPO-SIDE label: the\n * published Terms carry a \"Last updated\" date and no version string at all, so\n * the label can stay still while the text moves. Here the label is part of the\n * document a publisher reads. The two schemes are not the same kind of thing\n * and must not be reasoned about as one — that difference is the whole content\n * of this paragraph.\n *\n * On the merits it would have been a bump anyway: a forum-selection clause is\n * substance, not a typo — it names the court a publisher would have to travel\n * to. The 2026-08-22 cost argument is unchanged and still cheap, production\n * holding exactly one acceptance record which is the own.\n *\n * §8.1 and §8.3 are UNTOUCHED and were already correct: they have said Aglyn is\n * merchant of record and determines, collects and remits transaction tax since\n * 2026-08-14. The Terms of Service moved TO them in this pass (new ToS §10.7),\n * not the other way around.\n */\nexport const PUBLISHER_AGREEMENT_VERSION = '2026-08-24.1'\n\nexport const PUBLISHER_AGREEMENT_TITLE = 'Marketplace Publisher Agreement'\n\n/**\n * The snapshot pin for the version above (AGL-1678).\n *\n * A version string is a label we control and can reuse, so on its own it\n * proves nothing about what a publisher actually read. These two values pin\n * the archived snapshot at\n * `legal/publisher-agreement/{PUBLISHER_AGREEMENT_VERSION}/marketplace-publisher-agreement.txt`\n * (beside this module), captured FROM THE LIVE PAGE after publication — the\n * same publication-first machinery as the signup clickwrap\n * (`apps/console/constants/legal-documents.ts`, AGL-1497), and deliberately a\n * PARALLEL manifest rather than an entry in `LEGAL_DOCUMENTS`: ToS §19.1 makes\n * that set the entire signup agreement, and the publisher agreement is\n * deliberately not part of it. Mixing them would widen what a signup\n * acceptance covers.\n *\n * Both values go onto every acceptance record, so a record is self-contained\n * evidence of content and later tampering with the archive is detectable\n * rather than invisible. `publisher-agreement-version.spec.ts` re-hashes the\n * snapshot, so one version string can never come to mean two different\n * documents.\n *\n * Capture method (proven byte-for-byte against the clickwrap v4 hashes before\n * this snapshot was taken): fetch the live page, walk its HTML text nodes\n * skipping script/style, trim each, drop empties, take the document's content\n * block (first line `Last updated: …` through its closing `© …` line,\n * excluding site chrome and the table of contents), join with `\\n`, and end\n * with a trailing newline. UTF-8 throughout.\n *\n * TO PUBLISH A CHANGE: publish the besigner edit first, confirm the live page\n * serves it, capture a new snapshot under the new version's directory, then\n * bump `PUBLISHER_AGREEMENT_VERSION` and these two values together. Never\n * hand-write a snapshot: it is evidence of what a publisher was shown, and a\n * snapshot of unpublished text is a false record.\n */\nexport const PUBLISHER_AGREEMENT_SHA256 =\n  '2df6e940f037b4630e53c8f63bad8604ef4bf370374b89afcd4ea7f9fe8e8d63'\n\n/** Byte length of the same snapshot — a cheap second check on the content. */\nexport const PUBLISHER_AGREEMENT_BYTES = 13730\n\n/**\n * Canonical document, on the operator's legal origin beside the other terms.\n *\n * Built from `LEGAL_ORIGIN` (AGL-2196), which this module already depends on:\n * `publisherAgreementIsPublished` below calls `isPublishedLegalUrl`, and that\n * accepts ONLY `LEGAL_ORIGIN`. So the gate was operator-aware while the link\n * it gates was a bare `aglyn.com` literal — meaning on a self-host install\n * with `NEXT_PUBLIC_OPERATOR_LEGAL_ORIGIN` set, the gate rejected the very URL\n * this file handed it, and every publisher was blocked from accepting. One\n * origin for both closes that, and leaves Aglyn's own URL byte-identical.\n */\nexport const PUBLISHER_AGREEMENT_URL = `${LEGAL_ORIGIN}/legal/marketplace-publisher-agreement`\n\n/**\n * Whether that document can actually be read (AGL-1660).\n *\n * It could not, from the day this gate shipped until the day this check did:\n * the URL above 404ed, and the console still rendered it as \"Read the full\n * Marketplace Publisher Agreement\" above an Accept button. An acceptance\n * collected that way is a signature on a blank page — the same\n * publication-first principle the clickwrap snapshots are built on, failing in\n * the one place the text was never published at all.\n *\n * Derived, not a second flag: it reads `PUBLISHED_LEGAL_PATHS`, so the ONE\n * edit that adds the path when the page goes live is what re-opens acceptance\n * everywhere. There is no boolean to forget to flip, and no way for the link\n * and the gate to disagree.\n */\nexport function publisherAgreementIsPublished(\n  url: string = PUBLISHER_AGREEMENT_URL,\n): boolean {\n  return isPublishedLegalUrl(url)\n}\n\n/**\n * What a publisher is told while the document has no page.\n *\n * Deliberately not \"try again later\" — it names the reason, because the fix is\n * ours and the publisher can do nothing about it. It must never read as though\n * accepting is something they merely have not got round to.\n */\nexport const PUBLISHER_AGREEMENT_UNAVAILABLE_NOTICE =\n  `The ${PUBLISHER_AGREEMENT_TITLE} is not published yet, so there is ` +\n  'nothing here for you to read — and we will not ask you to agree to a ' +\n  'document we have not shown you. Acceptance is paused until it is ' +\n  'available, which also means marketplace publishing is paused. Nothing is ' +\n  'required of you in the meantime.'\n\n/**\n * What the agreement actually commits a publisher to.\n *\n * Shown above the accept control. A link alone is the pattern that produces\n * agreements nobody has read; these are the terms most likely to surprise\n * someone later, in the words they would need at that moment. They summarise\n * the document — they are not it, and the copy says so.\n */\nexport const PUBLISHER_AGREEMENT_POINTS: readonly {\n  id: string\n  label: string\n  detail: string\n}[] = [\n  {\n    id: 'hosting-license',\n    label: 'We may host, verify and distribute what you publish',\n    detail:\n      'Including keeping an immutable copy of every version, inspecting its code, and showing your listing content in the marketplace and console.',\n  },\n  {\n    id: 'warranties',\n    label: 'You warrant each version as you publish it',\n    detail:\n      'That you have the right to publish it, that its license is accurate and compatible, that it carries no malware or hidden telemetry, and that its documentation describes what it does with data.',\n  },\n  {\n    id: 'immutable',\n    label: 'You cannot recall code that is already installed',\n    detail:\n      'Installs pin an exact version and hash. A mistake ships until an installer chooses to upgrade — publishing a new version is the only remedy you have.',\n  },\n  {\n    id: 'revocation',\n    label: 'We can disable a version everywhere, without notice',\n    detail:\n      'If a version looks like a security, legal or privacy risk we stop it on every site running it, and tell you afterwards. Operating a platform that executes other people’s code requires this.',\n  },\n  {\n    id: 'review',\n    label: 'Review is a safety screen, not an endorsement',\n    detail:\n      'Approval is not an audit and not a guarantee your plugin works. We may decline, delist or unsign anything, for reasons that may have nothing to do with your code.',\n  },\n  {\n    id: 'payouts',\n    label: 'On paid listings we process the sale and take a fee',\n    detail:\n      'We process the purchase and pay your share into your own Stripe Connect account, less a platform fee that may change. We collect and remit sales tax on Marketplace sales; refunds, chargebacks and support on your Artifacts are yours.',\n  },\n  {\n    id: 'indemnity',\n    label: 'You indemnify us for claims arising from what you publish',\n    detail:\n      'Including infringement claims and disputes with the organizations that install it.',\n  },\n]\n\n/**\n * A recorded acceptance: which version, of which exact bytes, by whom, when.\n *\n * `sha256`/`bytes` (AGL-1678) pin the acceptance to the archived snapshot of\n * the text the publisher was shown. Optional because records written before\n * the pin existed carry only the version string — absence means \"accepted\n * before 2026-08-17\", not \"accepted nothing\".\n */\nexport interface PublisherAgreementAcceptance {\n  version?: string\n  sha256?: string\n  bytes?: number\n  acceptedBy?: string\n  acceptedAt?: unknown\n}\n\n/**\n * Where an org stands with the agreement.\n *\n * `none` and `outdated` are deliberately different answers. \"You have never\n * agreed to anything\" and \"the terms changed since you agreed\" are different\n * situations with different copy, and collapsing them into a boolean is how\n * a re-acceptance ends up reading like a first-time setup step.\n */\nexport type PublisherAgreementState = 'none' | 'outdated' | 'current'\n\nexport function publisherAgreementState(\n  acceptance: PublisherAgreementAcceptance | null | undefined,\n  currentVersion: string = PUBLISHER_AGREEMENT_VERSION,\n): PublisherAgreementState {\n  const accepted = acceptance?.version\n  if (typeof accepted !== 'string' || !accepted.trim()) return 'none'\n  return accepted === currentVersion ? 'current' : 'outdated'\n}\n\n/**\n * Whether a publish may proceed.\n *\n * An older acceptance is NOT carried forward. Whoever publishes next reads\n * the changed agreement and accepts it, or does not publish — silently\n * inheriting an acceptance across a rewrite is precisely what makes the\n * record worthless.\n */\nexport function hasCurrentPublisherAgreement(\n  acceptance: PublisherAgreementAcceptance | null | undefined,\n  currentVersion: string = PUBLISHER_AGREEMENT_VERSION,\n): boolean {\n  return publisherAgreementState(acceptance, currentVersion) === 'current'\n}\n\n/**\n * What the acceptance UI may show (AGL-1660).\n *\n * The gate lives HERE rather than in the panel, for the reason every \"check it\n * in the component\" control eventually fails: the component is not the only\n * caller. The accept route consults the same function, so a client that skips\n * the UI entirely meets the same answer.\n *\n * `documentUrl` is null, not the URL, when the document is unpublished — the\n * console reads the link target from this, so an unreadable document is\n * structurally unable to reach an href.\n */\nexport interface PublisherAgreementPresentation {\n  /** The document to link, or null when there is no page to link to. */\n  documentUrl: string | null\n  /** Whether the accept control may be offered at all. */\n  canAccept: boolean\n  /** Why acceptance is unavailable, or null when it is available. */\n  unavailableNotice: string | null\n}\n\nexport function publisherAgreementPresentation(\n  state: PublisherAgreementState,\n  published: boolean = publisherAgreementIsPublished(),\n): PublisherAgreementPresentation {\n  return {\n    documentUrl: published ? PUBLISHER_AGREEMENT_URL : null,\n    // Already current is not \"cannot accept because unpublished\" — it is\n    // nothing left to do, and the panel says so separately.\n    canAccept: published && state !== 'current',\n    unavailableNotice: published ? null : PUBLISHER_AGREEMENT_UNAVAILABLE_NOTICE,\n  }\n}\n\n/** The refusal a publisher sees, saying which of the two problems it is. */\nexport function publisherAgreementRefusal(\n  state: PublisherAgreementState,\n  published: boolean = publisherAgreementIsPublished(),\n): string {\n  // Sending someone to a control we have disabled is worse than saying\n  // nothing: they go, find no button, and conclude the console is broken.\n  if (!published) {\n    return (\n      `The ${PUBLISHER_AGREEMENT_TITLE} is not published yet, so it cannot ` +\n      'be accepted and publishing is paused for everyone. This is on us, not ' +\n      'on your organization.'\n    )\n  }\n  return state === 'outdated'\n    ? `The ${PUBLISHER_AGREEMENT_TITLE} has changed since your organization ` +\n        'accepted it. Review and accept the current version in Marketplace → ' +\n        'Publisher Profile, then publish.'\n    : `Your organization has not accepted the ${PUBLISHER_AGREEMENT_TITLE}. ` +\n        'Accept it in Marketplace → Publisher Profile, then publish.'\n}\n"],"names":["LEGAL_ORIGIN","isPublishedLegalUrl","PUBLISHER_AGREEMENT_VERSION","PUBLISHER_AGREEMENT_TITLE","PUBLISHER_AGREEMENT_SHA256","PUBLISHER_AGREEMENT_BYTES","PUBLISHER_AGREEMENT_URL","publisherAgreementIsPublished","url","PUBLISHER_AGREEMENT_UNAVAILABLE_NOTICE","PUBLISHER_AGREEMENT_POINTS","id","label","detail","publisherAgreementState","acceptance","currentVersion","accepted","version","trim","hasCurrentPublisherAgreement","publisherAgreementPresentation","state","published","documentUrl","canAccept","unavailableNotice","publisherAgreementRefusal"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;CAgBC,GAED,SAASA,YAAY,EAAEC,mBAAmB,QAAQ,6BAAyB;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FC,GACD,OAAO,MAAMC,8BAA8B,eAAc;AAEzD,OAAO,MAAMC,4BAA4B,kCAAiC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCC,GACD,OAAO,MAAMC,6BACX,mEAAkE;AAEpE,4EAA4E,GAC5E,OAAO,MAAMC,4BAA4B,MAAK;AAE9C;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,0BAA0B,GAAGN,aAAa,sCAAsC,CAAC,CAAA;AAE9F;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASO,8BACdC,MAAcF,uBAAuB;IAErC,OAAOL,oBAAoBO;AAC7B;AAEA;;;;;;CAMC,GACD,OAAO,MAAMC,yCACX,CAAC,IAAI,EAAEN,0BAA0B,mCAAmC,CAAC,GACrE,0EACA,sEACA,8EACA,mCAAkC;AAEpC;;;;;;;CAOC,GACD,OAAO,MAAMO,6BAIP;IACJ;QACEC,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;CACD,CAAA;AA4BD,OAAO,SAASC,wBACdC,UAA2D,EAC3DC,iBAAyBd,2BAA2B;IAEpD,MAAMe,WAAWF,8BAAAA,WAAYG,OAAO;IACpC,IAAI,OAAOD,aAAa,YAAY,CAACA,SAASE,IAAI,IAAI,OAAO;IAC7D,OAAOF,aAAaD,iBAAiB,YAAY;AACnD;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,6BACdL,UAA2D,EAC3DC,iBAAyBd,2BAA2B;IAEpD,OAAOY,wBAAwBC,YAAYC,oBAAoB;AACjE;AAuBA,OAAO,SAASK,+BACdC,KAA8B,EAC9BC,YAAqBhB,+BAA+B;IAEpD,OAAO;QACLiB,aAAaD,YAAYjB,0BAA0B;QACnD,qEAAqE;QACrE,wDAAwD;QACxDmB,WAAWF,aAAaD,UAAU;QAClCI,mBAAmBH,YAAY,OAAOd;IACxC;AACF;AAEA,0EAA0E,GAC1E,OAAO,SAASkB,0BACdL,KAA8B,EAC9BC,YAAqBhB,+BAA+B;IAEpD,qEAAqE;IACrE,wEAAwE;IACxE,IAAI,CAACgB,WAAW;QACd,OACE,CAAC,IAAI,EAAEpB,0BAA0B,oCAAoC,CAAC,GACtE,2EACA;IAEJ;IACA,OAAOmB,UAAU,aACb,CAAC,IAAI,EAAEnB,0BAA0B,qCAAqC,CAAC,GACrE,yEACA,qCACF,CAAC,uCAAuC,EAAEA,0BAA0B,EAAE,CAAC,GACrE;AACR"}

package/src/lib/app-utils/publisher-attestation.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export interface PublisherAttestationItem {
+    id: string;
+    /** First person — the publisher is the one saying it. */
+    label: string;
+    /** What they are actually committing to, shown under the item. */
+    detail: string;
+    /**
+     * Only asked when the listing already exists. A first submission has no
+     * "since the last version", and asking anyway teaches publishers that
+     * some of these boxes are noise.
+     */
+    updateOnly?: boolean;
+    /**
+     * The submitted field this item is a claim ABOUT (AGL-1076).
+     *
+     * An attestation whose subject is absent is a statement about nothing:
+     * `repository` shipped for a while confirming that a repository URL is
+     * public and matches, in a form with nowhere to name a repository, on
+     * listings whose `repositoryUrl` was empty. A reviewer opened it first and
+     * found nothing to open.
+     *
+     * So a subject makes the tick enforceable: the publish route refuses with
+     * the same 428 as a missing tick when the value is not in the request that
+     * stores it. Declared here rather than in the route so the form knows to
+     * ask for it and the route knows to require it from one place.
+     */
+    subject?: {
+        /** Key in the publish body, and on the listing/version doc. */
+        field: string;
+        /** How the field is labelled to the publisher, for the error. */
+        label: string;
+    };
+}
+export declare const PUBLISHER_ATTESTATION: readonly PublisherAttestationItem[];
+/** A stored attestation: who said it, when, and against which bytes. */
+export interface AttestationEntry {
+    by?: string;
+    at?: unknown;
+    sha256?: string;
+}
+/**
+ * The ids a submission must carry.
+ *
+ * `isUpdate` is decided server-side from whether a listing already exists,
+ * never from a client flag — otherwise "this is my first version" becomes a
+ * way to skip an item.
+ */
+export declare function requiredAttestationIds(isUpdate: boolean): string[];
+/**
+ * Which required attestations a submission is missing, given the ids the
+ * publisher ticked.
+ */
+export declare function missingAttestations(ticked: readonly string[] | null | undefined, isUpdate: boolean): string[];
+/** The fields a submission must carry alongside its ticks (AGL-1076). */
+export declare function attestationSubjects(isUpdate: boolean): Array<{
+    id: string;
+    field: string;
+    label: string;
+}>;
+/**
+ * Which required attestations have nothing to be about (AGL-1076).
+ *
+ * `values` is the submission being stored, never the listing doc: on a first
+ * publish there is no listing, and on an update the tick is a statement about
+ * what this publish declares, not about whatever the listing said last year.
+ */
+export declare function missingAttestationSubjects(values: Record<string, unknown> | null | undefined, isUpdate: boolean): Array<{
+    id: string;
+    field: string;
+    label: string;
+}>;
+/** Human labels for a set of ids, for an error a publisher can act on. */
+export declare function attestationLabels(ids: readonly string[]): string[];
+/**
+ * Which stored attestations count for a given bundle.
+ *
+ * Keyed to sha256 exactly like the staff checklist (AGL-963) and the
+ * verifier verdict (AGL-962): an attestation is a statement about specific
+ * bytes, so a republish under the same version string re-asks. Carrying
+ * ticks across a rebuild would let a publisher attest to code they then
+ * replaced.
+ */
+export declare function attestationsForBytes(attestation: Record<string, AttestationEntry> | null | undefined, sha256: string): string[];

package/src/lib/app-utils/publisher-attestation.js

@@ -0,0 +1,158 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * What a publisher states about their own bundle before it enters the queue
+ * (AGL-969).
+ *
+ * Deliberately NOT the staff checklist. Those items are judgements *about*
+ * the publisher — "publisher is identifiable and contactable" is worthless
+ * as self-attestation, because the answer is always yes. Every item here is
+ * something only the publisher can know and a reviewer would otherwise have
+ * to guess at or chase by email: whether the repo really holds this code,
+ * whether they have the right to publish it, whether each declared host is
+ * actually reached.
+ *
+ * Two things come out of this. Most review round-trips are questions the
+ * publisher could have answered at submit time, so the queue moves faster.
+ * And a false attestation is a timestamped statement by a named publisher
+ * against specific bytes, which makes takedown a documented consequence
+ * rather than a judgement call.
+ *
+ * This module is shared on purpose: the publish API is the enforcement
+ * point, the upload dialog renders the same list, and the review page shows
+ * staff what was claimed. Three copies of these strings would drift, and a
+ * drifted attestation is one nobody can be held to.
+ */ import { PLATFORM_BRAND_NAME } from "./platform-brand.js";
+export const PUBLISHER_ATTESTATION = [
+    {
+        id: 'repository',
+        label: 'The repository URL is public and contains the source for this bundle',
+        detail: 'A reviewer opens it first. A repo that 404s, is private, or holds something unrelated is the cheapest reason a submission gets sent back.',
+        subject: {
+            field: 'repositoryUrl',
+            label: 'Repository URL'
+        }
+    },
+    {
+        id: 'license',
+        label: 'A license is included and I have the right to publish this code',
+        detail: 'Missing or incompatible licensing is a legal problem for every workspace that installs it, not only for us.'
+    },
+    {
+        id: 'data-disclosure',
+        label: 'The README documents what data this plugin reads, stores or sends, and where it goes',
+        detail: 'Anything the plugin does with member or page data belongs in the README before it is installed, not in a support thread afterwards.'
+    },
+    {
+        id: 'network-hosts',
+        label: 'Every declared network host is required — I have removed the ones I do not use',
+        detail: 'Declared hosts become this plugin’s CSP connect-src. An allowlist wider than the plugin needs is the single most common thing review sends back, and it widens the blast radius if the bundle is ever compromised.'
+    },
+    {
+        id: 'tested',
+        label: 'I have tested this version on a site I control',
+        detail: 'These exact bytes, not an earlier build. Static review cannot tell a reviewer what your plugin does at runtime.'
+    },
+    /**
+   * Publisher Agreement §3(h), which binds "Neither the Artifact nor its
+   * listing" — so it already reached the element names and descriptions a
+   * plugin declares in its manifest, which ship INSIDE the artifact. This
+   * sentence did not, and a publisher can only be held to what they were
+   * asked (AGL-2486).
+   *
+   * Written as a CAPABILITY — any text you supply that renders in, or ranks
+   * within, the console — rather than as a list of today's fields. The list
+   * was already wrong once: `tags` and `keywords` reached the picker's search
+   * ranking days after `description` reached its detail panel, and a sentence
+   * enumerating fields goes stale the next time one is added. Ranking is
+   * named explicitly because it is the non-obvious half: a search term never
+   * appears on screen, yet it decides which element a customer is SHOWN.
+   *
+   * The id stays `listing-conduct` deliberately. A stored tick is keyed by
+   * id (see {@link attestationsForBytes}), so renaming it to something truer
+   * to the widened wording would orphan every attestation on file as an
+   * unrecognised id, and re-ask for bytes already attested.
+   */ {
+        id: 'listing-conduct',
+        label: `Neither my listing nor any text on my elements disparages ${PLATFORM_BRAND_NAME}, quotes what its plans cost, or sells a way around one`,
+        detail: `Saying which ${PLATFORM_BRAND_NAME} plans or features your plugin needs, or works with, is fine and useful. Editorialising about ${PLATFORM_BRAND_NAME}’s prices or quotas, stating or implying what a plan contains, or pitching this version as a way to avoid a plan or an upgrade is not. This covers any text you supply that renders in — or ranks within — the console, not only the listing: an element’s name, description, tags, search keywords and attribute labels all ship inside your bundle, and a customer meets them in their own element picker. Search terms count even though nobody reads them, because they decide which element gets shown.`
+    },
+    {
+        id: 'changelog',
+        label: 'The changelog describes what changed since the last version',
+        detail: 'An update is where something slips through — the first version gets read closely, the fourth rarely does. Saying what moved is what makes reviewing a diff possible.',
+        updateOnly: true
+    }
+];
+/**
+ * The ids a submission must carry.
+ *
+ * `isUpdate` is decided server-side from whether a listing already exists,
+ * never from a client flag — otherwise "this is my first version" becomes a
+ * way to skip an item.
+ */ export function requiredAttestationIds(isUpdate) {
+    return PUBLISHER_ATTESTATION.filter((item)=>isUpdate || !item.updateOnly).map((item)=>item.id);
+}
+/**
+ * Which required attestations a submission is missing, given the ids the
+ * publisher ticked.
+ */ export function missingAttestations(ticked, isUpdate) {
+    const given = new Set(ticked != null ? ticked : []);
+    return requiredAttestationIds(isUpdate).filter((id)=>!given.has(id));
+}
+/** The fields a submission must carry alongside its ticks (AGL-1076). */ export function attestationSubjects(isUpdate) {
+    return PUBLISHER_ATTESTATION.filter((item)=>item.subject && (isUpdate || !item.updateOnly)).map((item)=>{
+        var _ref, _ref1;
+        var _item_subject, _item_subject1;
+        return {
+            id: item.id,
+            field: (_ref = (_item_subject = item.subject) == null ? void 0 : _item_subject.field) != null ? _ref : '',
+            label: (_ref1 = (_item_subject1 = item.subject) == null ? void 0 : _item_subject1.label) != null ? _ref1 : ''
+        };
+    });
+}
+/**
+ * Which required attestations have nothing to be about (AGL-1076).
+ *
+ * `values` is the submission being stored, never the listing doc: on a first
+ * publish there is no listing, and on an update the tick is a statement about
+ * what this publish declares, not about whatever the listing said last year.
+ */ export function missingAttestationSubjects(values, isUpdate) {
+    return attestationSubjects(isUpdate).filter((subject)=>{
+        const value = (values != null ? values : {})[subject.field];
+        return typeof value !== 'string' || !value.trim();
+    });
+}
+/** Human labels for a set of ids, for an error a publisher can act on. */ export function attestationLabels(ids) {
+    return ids.map((id)=>{
+        var _PUBLISHER_ATTESTATION_find;
+        return (_PUBLISHER_ATTESTATION_find = PUBLISHER_ATTESTATION.find((item)=>item.id === id)) == null ? void 0 : _PUBLISHER_ATTESTATION_find.label;
+    }).filter((label)=>Boolean(label));
+}
+/**
+ * Which stored attestations count for a given bundle.
+ *
+ * Keyed to sha256 exactly like the staff checklist (AGL-963) and the
+ * verifier verdict (AGL-962): an attestation is a statement about specific
+ * bytes, so a republish under the same version string re-asks. Carrying
+ * ticks across a rebuild would let a publisher attest to code they then
+ * replaced.
+ */ export function attestationsForBytes(attestation, sha256) {
+    if (!sha256) return [];
+    return Object.entries(attestation != null ? attestation : {}).filter(([, entry])=>(entry == null ? void 0 : entry.sha256) === sha256).map(([id])=>id);
+}
+
+//# sourceMappingURL=publisher-attestation.js.map

package/src/lib/app-utils/publisher-attestation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/publisher-attestation.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * What a publisher states about their own bundle before it enters the queue\n * (AGL-969).\n *\n * Deliberately NOT the staff checklist. Those items are judgements *about*\n * the publisher — \"publisher is identifiable and contactable\" is worthless\n * as self-attestation, because the answer is always yes. Every item here is\n * something only the publisher can know and a reviewer would otherwise have\n * to guess at or chase by email: whether the repo really holds this code,\n * whether they have the right to publish it, whether each declared host is\n * actually reached.\n *\n * Two things come out of this. Most review round-trips are questions the\n * publisher could have answered at submit time, so the queue moves faster.\n * And a false attestation is a timestamped statement by a named publisher\n * against specific bytes, which makes takedown a documented consequence\n * rather than a judgement call.\n *\n * This module is shared on purpose: the publish API is the enforcement\n * point, the upload dialog renders the same list, and the review page shows\n * staff what was claimed. Three copies of these strings would drift, and a\n * drifted attestation is one nobody can be held to.\n */\nimport { PLATFORM_BRAND_NAME } from './platform-brand'\n\nexport interface PublisherAttestationItem {\n  id: string\n  /** First person — the publisher is the one saying it. */\n  label: string\n  /** What they are actually committing to, shown under the item. */\n  detail: string\n  /**\n   * Only asked when the listing already exists. A first submission has no\n   * \"since the last version\", and asking anyway teaches publishers that\n   * some of these boxes are noise.\n   */\n  updateOnly?: boolean\n  /**\n   * The submitted field this item is a claim ABOUT (AGL-1076).\n   *\n   * An attestation whose subject is absent is a statement about nothing:\n   * `repository` shipped for a while confirming that a repository URL is\n   * public and matches, in a form with nowhere to name a repository, on\n   * listings whose `repositoryUrl` was empty. A reviewer opened it first and\n   * found nothing to open.\n   *\n   * So a subject makes the tick enforceable: the publish route refuses with\n   * the same 428 as a missing tick when the value is not in the request that\n   * stores it. Declared here rather than in the route so the form knows to\n   * ask for it and the route knows to require it from one place.\n   */\n  subject?: {\n    /** Key in the publish body, and on the listing/version doc. */\n    field: string\n    /** How the field is labelled to the publisher, for the error. */\n    label: string\n  }\n}\n\nexport const PUBLISHER_ATTESTATION: readonly PublisherAttestationItem[] = [\n  {\n    id: 'repository',\n    label: 'The repository URL is public and contains the source for this bundle',\n    detail:\n      'A reviewer opens it first. A repo that 404s, is private, or holds something unrelated is the cheapest reason a submission gets sent back.',\n    subject: { field: 'repositoryUrl', label: 'Repository URL' },\n  },\n  {\n    id: 'license',\n    label: 'A license is included and I have the right to publish this code',\n    detail:\n      'Missing or incompatible licensing is a legal problem for every workspace that installs it, not only for us.',\n  },\n  {\n    id: 'data-disclosure',\n    label:\n      'The README documents what data this plugin reads, stores or sends, and where it goes',\n    detail:\n      'Anything the plugin does with member or page data belongs in the README before it is installed, not in a support thread afterwards.',\n  },\n  {\n    id: 'network-hosts',\n    label:\n      'Every declared network host is required — I have removed the ones I do not use',\n    detail:\n      'Declared hosts become this plugin’s CSP connect-src. An allowlist wider than the plugin needs is the single most common thing review sends back, and it widens the blast radius if the bundle is ever compromised.',\n  },\n  {\n    id: 'tested',\n    label: 'I have tested this version on a site I control',\n    detail:\n      'These exact bytes, not an earlier build. Static review cannot tell a reviewer what your plugin does at runtime.',\n  },\n  /**\n   * Publisher Agreement §3(h), which binds \"Neither the Artifact nor its\n   * listing\" — so it already reached the element names and descriptions a\n   * plugin declares in its manifest, which ship INSIDE the artifact. This\n   * sentence did not, and a publisher can only be held to what they were\n   * asked (AGL-2486).\n   *\n   * Written as a CAPABILITY — any text you supply that renders in, or ranks\n   * within, the console — rather than as a list of today's fields. The list\n   * was already wrong once: `tags` and `keywords` reached the picker's search\n   * ranking days after `description` reached its detail panel, and a sentence\n   * enumerating fields goes stale the next time one is added. Ranking is\n   * named explicitly because it is the non-obvious half: a search term never\n   * appears on screen, yet it decides which element a customer is SHOWN.\n   *\n   * The id stays `listing-conduct` deliberately. A stored tick is keyed by\n   * id (see {@link attestationsForBytes}), so renaming it to something truer\n   * to the widened wording would orphan every attestation on file as an\n   * unrecognised id, and re-ask for bytes already attested.\n   */\n  {\n    id: 'listing-conduct',\n    label:\n      `Neither my listing nor any text on my elements disparages ${PLATFORM_BRAND_NAME}, quotes what its plans cost, or sells a way around one`,\n    detail:\n      `Saying which ${PLATFORM_BRAND_NAME} plans or features your plugin needs, or works with, is fine and useful. Editorialising about ${PLATFORM_BRAND_NAME}’s prices or quotas, stating or implying what a plan contains, or pitching this version as a way to avoid a plan or an upgrade is not. This covers any text you supply that renders in — or ranks within — the console, not only the listing: an element’s name, description, tags, search keywords and attribute labels all ship inside your bundle, and a customer meets them in their own element picker. Search terms count even though nobody reads them, because they decide which element gets shown.`,\n  },\n  {\n    id: 'changelog',\n    label: 'The changelog describes what changed since the last version',\n    detail:\n      'An update is where something slips through — the first version gets read closely, the fourth rarely does. Saying what moved is what makes reviewing a diff possible.',\n    updateOnly: true,\n  },\n]\n\n/** A stored attestation: who said it, when, and against which bytes. */\nexport interface AttestationEntry {\n  by?: string\n  at?: unknown\n  sha256?: string\n}\n\n/**\n * The ids a submission must carry.\n *\n * `isUpdate` is decided server-side from whether a listing already exists,\n * never from a client flag — otherwise \"this is my first version\" becomes a\n * way to skip an item.\n */\nexport function requiredAttestationIds(isUpdate: boolean): string[] {\n  return PUBLISHER_ATTESTATION.filter(\n    (item) => isUpdate || !item.updateOnly,\n  ).map((item) => item.id)\n}\n\n/**\n * Which required attestations a submission is missing, given the ids the\n * publisher ticked.\n */\nexport function missingAttestations(\n  ticked: readonly string[] | null | undefined,\n  isUpdate: boolean,\n): string[] {\n  const given = new Set(ticked ?? [])\n  return requiredAttestationIds(isUpdate).filter((id) => !given.has(id))\n}\n\n/** The fields a submission must carry alongside its ticks (AGL-1076). */\nexport function attestationSubjects(\n  isUpdate: boolean,\n): Array<{ id: string; field: string; label: string }> {\n  return PUBLISHER_ATTESTATION.filter(\n    (item) => item.subject && (isUpdate || !item.updateOnly),\n  ).map((item) => ({\n    id: item.id,\n    field: item.subject?.field ?? '',\n    label: item.subject?.label ?? '',\n  }))\n}\n\n/**\n * Which required attestations have nothing to be about (AGL-1076).\n *\n * `values` is the submission being stored, never the listing doc: on a first\n * publish there is no listing, and on an update the tick is a statement about\n * what this publish declares, not about whatever the listing said last year.\n */\nexport function missingAttestationSubjects(\n  values: Record<string, unknown> | null | undefined,\n  isUpdate: boolean,\n): Array<{ id: string; field: string; label: string }> {\n  return attestationSubjects(isUpdate).filter((subject) => {\n    const value = (values ?? {})[subject.field]\n    return typeof value !== 'string' || !value.trim()\n  })\n}\n\n/** Human labels for a set of ids, for an error a publisher can act on. */\nexport function attestationLabels(ids: readonly string[]): string[] {\n  return ids\n    .map((id) => PUBLISHER_ATTESTATION.find((item) => item.id === id)?.label)\n    .filter((label): label is string => Boolean(label))\n}\n\n/**\n * Which stored attestations count for a given bundle.\n *\n * Keyed to sha256 exactly like the staff checklist (AGL-963) and the\n * verifier verdict (AGL-962): an attestation is a statement about specific\n * bytes, so a republish under the same version string re-asks. Carrying\n * ticks across a rebuild would let a publisher attest to code they then\n * replaced.\n */\nexport function attestationsForBytes(\n  attestation: Record<string, AttestationEntry> | null | undefined,\n  sha256: string,\n): string[] {\n  if (!sha256) return []\n  return Object.entries(attestation ?? {})\n    .filter(([, entry]) => entry?.sha256 === sha256)\n    .map(([id]) => id)\n}\n"],"names":["PLATFORM_BRAND_NAME","PUBLISHER_ATTESTATION","id","label","detail","subject","field","updateOnly","requiredAttestationIds","isUpdate","filter","item","map","missingAttestations","ticked","given","Set","has","attestationSubjects","missingAttestationSubjects","values","value","trim","attestationLabels","ids","find","Boolean","attestationsForBytes","attestation","sha256","Object","entries","entry"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,SAASA,mBAAmB,QAAQ,sBAAkB;AAoCtD,OAAO,MAAMC,wBAA6D;IACxE;QACEC,IAAI;QACJC,OAAO;QACPC,QACE;QACFC,SAAS;YAAEC,OAAO;YAAiBH,OAAO;QAAiB;IAC7D;IACA;QACED,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OACE;QACFC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OACE;QACFC,QACE;IACJ;IACA;QACEF,IAAI;QACJC,OAAO;QACPC,QACE;IACJ;IACA;;;;;;;;;;;;;;;;;;;GAmBC,GACD;QACEF,IAAI;QACJC,OACE,CAAC,0DAA0D,EAAEH,oBAAoB,uDAAuD,CAAC;QAC3II,QACE,CAAC,aAAa,EAAEJ,oBAAoB,8FAA8F,EAAEA,oBAAoB,4eAA4e,CAAC;IACzoB;IACA;QACEE,IAAI;QACJC,OAAO;QACPC,QACE;QACFG,YAAY;IACd;CACD,CAAA;AASD;;;;;;CAMC,GACD,OAAO,SAASC,uBAAuBC,QAAiB;IACtD,OAAOR,sBAAsBS,MAAM,CACjC,CAACC,OAASF,YAAY,CAACE,KAAKJ,UAAU,EACtCK,GAAG,CAAC,CAACD,OAASA,KAAKT,EAAE;AACzB;AAEA;;;CAGC,GACD,OAAO,SAASW,oBACdC,MAA4C,EAC5CL,QAAiB;IAEjB,MAAMM,QAAQ,IAAIC,IAAIF,iBAAAA,SAAU,EAAE;IAClC,OAAON,uBAAuBC,UAAUC,MAAM,CAAC,CAACR,KAAO,CAACa,MAAME,GAAG,CAACf;AACpE;AAEA,uEAAuE,GACvE,OAAO,SAASgB,oBACdT,QAAiB;IAEjB,OAAOR,sBAAsBS,MAAM,CACjC,CAACC,OAASA,KAAKN,OAAO,IAAKI,CAAAA,YAAY,CAACE,KAAKJ,UAAU,AAAD,GACtDK,GAAG,CAAC,CAACD;;YAEEA,eACAA;eAHQ;YACfT,IAAIS,KAAKT,EAAE;YACXI,KAAK,WAAEK,gBAAAA,KAAKN,OAAO,qBAAZM,cAAcL,KAAK,mBAAI;YAC9BH,KAAK,YAAEQ,iBAAAA,KAAKN,OAAO,qBAAZM,eAAcR,KAAK,oBAAI;QAChC;;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASgB,2BACdC,MAAkD,EAClDX,QAAiB;IAEjB,OAAOS,oBAAoBT,UAAUC,MAAM,CAAC,CAACL;QAC3C,MAAMgB,QAAQ,CAACD,iBAAAA,SAAU,CAAC,EAAE,CAACf,QAAQC,KAAK,CAAC;QAC3C,OAAO,OAAOe,UAAU,YAAY,CAACA,MAAMC,IAAI;IACjD;AACF;AAEA,wEAAwE,GACxE,OAAO,SAASC,kBAAkBC,GAAsB;IACtD,OAAOA,IACJZ,GAAG,CAAC,CAACV;YAAOD;gBAAAA,8BAAAA,sBAAsBwB,IAAI,CAAC,CAACd,OAASA,KAAKT,EAAE,KAAKA,wBAAjDD,4BAAsDE,KAAK;OACvEO,MAAM,CAAC,CAACP,QAA2BuB,QAAQvB;AAChD;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASwB,qBACdC,WAAgE,EAChEC,MAAc;IAEd,IAAI,CAACA,QAAQ,OAAO,EAAE;IACtB,OAAOC,OAAOC,OAAO,CAACH,sBAAAA,cAAe,CAAC,GACnClB,MAAM,CAAC,CAAC,GAAGsB,MAAM,GAAKA,CAAAA,yBAAAA,MAAOH,MAAM,MAAKA,QACxCjB,GAAG,CAAC,CAAC,CAACV,GAAG,GAAKA;AACnB"}