@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/marketplace-update-state.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @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.
+ */
+import type { MarketplaceArtifactType } from './marketplace-provenance';
+import { type PluginRevocation } from './plugin-manifest';
+/**
+ * "Is what I have installed still what the publisher ships?" (AGL-1016).
+ *
+ * This comparison was previously derived inline on the installed-plugins card
+ * and nowhere else, so the Plugins index, the installation page and the
+ * marketplace listing could each show a different answer — or none. It is
+ * exactly the sort of thing that gets re-derived slightly differently in four
+ * places, so it lives here, pure, and every surface asks it.
+ */
+export type UpdateState = 
+/** Running the newest version the publisher offers. */
+'current'
+/** A newer version exists and can be taken. */
+ | 'update-available'
+/**
+ * Installed version is NEWER than what is offered. Not a bug: a publisher
+ * installs their own unapproved version to test it, and a version can be
+ * withdrawn after someone installed it.
+ */
+ | 'ahead'
+/** Not enough is known to say — no provenance, or nothing published to compare. */
+ | 'unknown';
+export interface UpdateStatus {
+    state: UpdateState;
+    /** The version running, or null when provenance cannot say. */
+    installedVersion: string | null;
+    /** The newest version on offer — for plugins, the newest APPROVED one. */
+    availableVersion: string | null;
+    /**
+     * Why the answer is `unknown`, for a UI that should say which kind of
+     * silence this is rather than implying the artifact is current.
+     */
+    unknownReason?: 'no-provenance' | 'nothing-published' | 'incomparable';
+}
+/**
+ * Orders two artifact versions, or returns null when they cannot be ordered.
+ *
+ * Two numbering schemes are in play and both are real: copied artifacts get a
+ * monotonic integer from the publish route, plugins get the semver string off
+ * their manifest. A single string compare handles neither ("10" < "9",
+ * "1.10.0" < "1.9.0"), so both are parsed as dotted numbers — which covers the
+ * integer case as a one-segment version.
+ *
+ * Anything non-numeric (a prerelease tag, a date-stamped build) is not ordered
+ * by guesswork: unequal-and-incomparable is reported as such and surfaces as
+ * `unknown`, which is honest, where a string compare would confidently point
+ * an update button at an older build.
+ */
+export declare function compareArtifactVersions(a: string | number | null | undefined, b: string | number | null | undefined): -1 | 0 | 1 | null;
+/** The installed side: a plugin pin, or any copied artifact's document. */
+export interface UpdateComparableInstall {
+    version?: unknown;
+    installedFrom?: Record<string, unknown> | null;
+    marketplace?: {
+        listingId?: string;
+        version?: unknown;
+    } | null;
+    source?: {
+        listingId?: string;
+        version?: unknown;
+    } | null;
+    listingId?: string;
+    pluginId?: string;
+    sha256?: string;
+}
+/** The listing side, as the public listing document carries it. */
+export interface UpdateComparableListing {
+    artifactType?: string;
+    type?: string;
+    kind?: string;
+    latestVersion?: unknown;
+    /**
+     * The newest version that PASSED REVIEW (AGL-966), denormalised onto the
+     * listing by the approval route because `pluginVersions` is server-only.
+     */
+    latestApprovedVersion?: unknown;
+}
+/**
+ * Compares what is installed against what the listing offers (AGL-1016).
+ *
+ * For plugins the offer is the newest INSTALLABLE version, never
+ * `latestVersion`. Installs already resolve it that way; advertising
+ * `latestVersion` would leak AGL-966's guarantee straight back out through a
+ * badge, telling a workspace an update exists that the install route would
+ * then refuse to give them.
+ *
+ * `revocation` is the same leak one state over (AGL-2368). Approval is a
+ * review verdict and the kill switch does not clear it, so `latestApprovedVersion`
+ * could name a stopped version — an "Update to vX" for bytes `install-plugin`
+ * answers 409 to. Optional because it is a second document and not every
+ * caller holds it; every writer of the mirror derives it from
+ * `newestInstallableVersion` since AGL-2306, so a caller without one is
+ * reading a cache that is correct except in the window between two writes.
+ * A caller that HAS it should pass it.
+ */
+export declare function resolveUpdateState(installed: UpdateComparableInstall | null | undefined, listing: UpdateComparableListing | null | undefined, artifactType?: MarketplaceArtifactType, revocation?: PluginRevocation | null): UpdateStatus;
+/**
+ * One sentence describing an update state, so four surfaces do not each invent
+ * their own wording for the same fact.
+ */
+export declare function updateStateLabel(status: UpdateStatus): string;

package/src/lib/app-utils/marketplace-update-state.js

@@ -0,0 +1,132 @@
+/**
+ * @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.
+ */ import { resolveProvenance } from "./marketplace-provenance.js";
+import { offeredPluginVersion } from "./plugin-manifest.js";
+/**
+ * Orders two artifact versions, or returns null when they cannot be ordered.
+ *
+ * Two numbering schemes are in play and both are real: copied artifacts get a
+ * monotonic integer from the publish route, plugins get the semver string off
+ * their manifest. A single string compare handles neither ("10" < "9",
+ * "1.10.0" < "1.9.0"), so both are parsed as dotted numbers — which covers the
+ * integer case as a one-segment version.
+ *
+ * Anything non-numeric (a prerelease tag, a date-stamped build) is not ordered
+ * by guesswork: unequal-and-incomparable is reported as such and surfaces as
+ * `unknown`, which is honest, where a string compare would confidently point
+ * an update button at an older build.
+ */ export function compareArtifactVersions(a, b) {
+    if (a == null || b == null || a === '' || b === '') return null;
+    const left = String(a);
+    const right = String(b);
+    if (left === right) return 0;
+    const parse = (value)=>{
+        const parts = value.split('.');
+        const numbers = [];
+        for (const part of parts){
+            if (!/^\d+$/.test(part)) return null;
+            numbers.push(Number(part));
+        }
+        return numbers.length ? numbers : null;
+    };
+    const leftParts = parse(left);
+    const rightParts = parse(right);
+    if (!leftParts || !rightParts) return null;
+    const length = Math.max(leftParts.length, rightParts.length);
+    for(let index = 0; index < length; index += 1){
+        var _leftParts_index, _rightParts_index;
+        const leftPart = (_leftParts_index = leftParts[index]) != null ? _leftParts_index : 0;
+        const rightPart = (_rightParts_index = rightParts[index]) != null ? _rightParts_index : 0;
+        if (leftPart < rightPart) return -1;
+        if (leftPart > rightPart) return 1;
+    }
+    // Equal numerically but not as strings — "1.0" and "1.0.0" are the same
+    // version written two ways.
+    return 0;
+}
+const UNKNOWN = {
+    state: 'unknown',
+    installedVersion: null,
+    availableVersion: null,
+    unknownReason: 'no-provenance'
+};
+/**
+ * Compares what is installed against what the listing offers (AGL-1016).
+ *
+ * For plugins the offer is the newest INSTALLABLE version, never
+ * `latestVersion`. Installs already resolve it that way; advertising
+ * `latestVersion` would leak AGL-966's guarantee straight back out through a
+ * badge, telling a workspace an update exists that the install route would
+ * then refuse to give them.
+ *
+ * `revocation` is the same leak one state over (AGL-2368). Approval is a
+ * review verdict and the kill switch does not clear it, so `latestApprovedVersion`
+ * could name a stopped version — an "Update to vX" for bytes `install-plugin`
+ * answers 409 to. Optional because it is a second document and not every
+ * caller holds it; every writer of the mirror derives it from
+ * `newestInstallableVersion` since AGL-2306, so a caller without one is
+ * reading a cache that is correct except in the window between two writes.
+ * A caller that HAS it should pass it.
+ */ export function resolveUpdateState(installed, listing, artifactType, revocation) {
+    var _ref, _provenance_artifactType;
+    const provenance = resolveProvenance(installed, artifactType);
+    if (!installed || provenance.state === 'unknown' || !provenance.version) {
+        return UNKNOWN;
+    }
+    const installedVersion = provenance.version;
+    const type = (_ref = (_provenance_artifactType = provenance.artifactType) != null ? _provenance_artifactType : artifactType) != null ? _ref : null;
+    const available = type === 'plugin' ? offeredPluginVersion(listing, revocation) : listing == null ? void 0 : listing.latestVersion;
+    if (available == null || available === '') {
+        return {
+            state: 'unknown',
+            installedVersion,
+            availableVersion: null,
+            unknownReason: 'nothing-published'
+        };
+    }
+    const availableVersion = String(available);
+    const order = compareArtifactVersions(installedVersion, availableVersion);
+    if (order === null) {
+        return {
+            state: 'unknown',
+            installedVersion,
+            availableVersion,
+            unknownReason: 'incomparable'
+        };
+    }
+    return {
+        state: order === 0 ? 'current' : order < 0 ? 'update-available' : 'ahead',
+        installedVersion,
+        availableVersion
+    };
+}
+/**
+ * One sentence describing an update state, so four surfaces do not each invent
+ * their own wording for the same fact.
+ */ export function updateStateLabel(status) {
+    switch(status.state){
+        case 'update-available':
+            return `You have v${status.installedVersion} · v${status.availableVersion} available`;
+        case 'current':
+            return `Up to date · v${status.installedVersion}`;
+        case 'ahead':
+            return `You have v${status.installedVersion}, newer than the published v${status.availableVersion}`;
+        default:
+            return status.unknownReason === 'nothing-published' ? 'No published version to compare against' : status.unknownReason === 'incomparable' ? `You have v${status.installedVersion}; v${status.availableVersion} cannot be ordered against it` : 'Installed before update tracking — version unknown';
+    }
+}
+
+//# sourceMappingURL=marketplace-update-state.js.map

package/src/lib/app-utils/marketplace-update-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/marketplace-update-state.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\nimport type { MarketplaceArtifactType } from './marketplace-provenance'\nimport { resolveProvenance } from './marketplace-provenance'\nimport {\n  offeredPluginVersion,\n  type PluginRevocation,\n} from './plugin-manifest'\n\n/**\n * \"Is what I have installed still what the publisher ships?\" (AGL-1016).\n *\n * This comparison was previously derived inline on the installed-plugins card\n * and nowhere else, so the Plugins index, the installation page and the\n * marketplace listing could each show a different answer — or none. It is\n * exactly the sort of thing that gets re-derived slightly differently in four\n * places, so it lives here, pure, and every surface asks it.\n */\n\nexport type UpdateState =\n  /** Running the newest version the publisher offers. */\n  | 'current'\n  /** A newer version exists and can be taken. */\n  | 'update-available'\n  /**\n   * Installed version is NEWER than what is offered. Not a bug: a publisher\n   * installs their own unapproved version to test it, and a version can be\n   * withdrawn after someone installed it.\n   */\n  | 'ahead'\n  /** Not enough is known to say — no provenance, or nothing published to compare. */\n  | 'unknown'\n\nexport interface UpdateStatus {\n  state: UpdateState\n  /** The version running, or null when provenance cannot say. */\n  installedVersion: string | null\n  /** The newest version on offer — for plugins, the newest APPROVED one. */\n  availableVersion: string | null\n  /**\n   * Why the answer is `unknown`, for a UI that should say which kind of\n   * silence this is rather than implying the artifact is current.\n   */\n  unknownReason?: 'no-provenance' | 'nothing-published' | 'incomparable'\n}\n\n/**\n * Orders two artifact versions, or returns null when they cannot be ordered.\n *\n * Two numbering schemes are in play and both are real: copied artifacts get a\n * monotonic integer from the publish route, plugins get the semver string off\n * their manifest. A single string compare handles neither (\"10\" < \"9\",\n * \"1.10.0\" < \"1.9.0\"), so both are parsed as dotted numbers — which covers the\n * integer case as a one-segment version.\n *\n * Anything non-numeric (a prerelease tag, a date-stamped build) is not ordered\n * by guesswork: unequal-and-incomparable is reported as such and surfaces as\n * `unknown`, which is honest, where a string compare would confidently point\n * an update button at an older build.\n */\nexport function compareArtifactVersions(\n  a: string | number | null | undefined,\n  b: string | number | null | undefined,\n): -1 | 0 | 1 | null {\n  if (a == null || b == null || a === '' || b === '') return null\n  const left = String(a)\n  const right = String(b)\n  if (left === right) return 0\n  const parse = (value: string): number[] | null => {\n    const parts = value.split('.')\n    const numbers: number[] = []\n    for (const part of parts) {\n      if (!/^\\d+$/.test(part)) return null\n      numbers.push(Number(part))\n    }\n    return numbers.length ? numbers : null\n  }\n  const leftParts = parse(left)\n  const rightParts = parse(right)\n  if (!leftParts || !rightParts) return null\n  const length = Math.max(leftParts.length, rightParts.length)\n  for (let index = 0; index < length; index += 1) {\n    const leftPart = leftParts[index] ?? 0\n    const rightPart = rightParts[index] ?? 0\n    if (leftPart < rightPart) return -1\n    if (leftPart > rightPart) return 1\n  }\n  // Equal numerically but not as strings — \"1.0\" and \"1.0.0\" are the same\n  // version written two ways.\n  return 0\n}\n\n/** The installed side: a plugin pin, or any copied artifact's document. */\nexport interface UpdateComparableInstall {\n  version?: unknown\n  installedFrom?: Record<string, unknown> | null\n  marketplace?: { listingId?: string; version?: unknown } | null\n  source?: { listingId?: string; version?: unknown } | null\n  listingId?: string\n  pluginId?: string\n  sha256?: string\n}\n\n/** The listing side, as the public listing document carries it. */\nexport interface UpdateComparableListing {\n  artifactType?: string\n  type?: string\n  kind?: string\n  latestVersion?: unknown\n  /**\n   * The newest version that PASSED REVIEW (AGL-966), denormalised onto the\n   * listing by the approval route because `pluginVersions` is server-only.\n   */\n  latestApprovedVersion?: unknown\n}\n\nconst UNKNOWN: UpdateStatus = {\n  state: 'unknown',\n  installedVersion: null,\n  availableVersion: null,\n  unknownReason: 'no-provenance',\n}\n\n/**\n * Compares what is installed against what the listing offers (AGL-1016).\n *\n * For plugins the offer is the newest INSTALLABLE version, never\n * `latestVersion`. Installs already resolve it that way; advertising\n * `latestVersion` would leak AGL-966's guarantee straight back out through a\n * badge, telling a workspace an update exists that the install route would\n * then refuse to give them.\n *\n * `revocation` is the same leak one state over (AGL-2368). Approval is a\n * review verdict and the kill switch does not clear it, so `latestApprovedVersion`\n * could name a stopped version — an \"Update to vX\" for bytes `install-plugin`\n * answers 409 to. Optional because it is a second document and not every\n * caller holds it; every writer of the mirror derives it from\n * `newestInstallableVersion` since AGL-2306, so a caller without one is\n * reading a cache that is correct except in the window between two writes.\n * A caller that HAS it should pass it.\n */\nexport function resolveUpdateState(\n  installed: UpdateComparableInstall | null | undefined,\n  listing: UpdateComparableListing | null | undefined,\n  artifactType?: MarketplaceArtifactType,\n  revocation?: PluginRevocation | null,\n): UpdateStatus {\n  const provenance = resolveProvenance(installed as never, artifactType)\n  if (!installed || provenance.state === 'unknown' || !provenance.version) {\n    return UNKNOWN\n  }\n  const installedVersion = provenance.version\n  const type = provenance.artifactType ?? artifactType ?? null\n  const available =\n    type === 'plugin'\n      ? offeredPluginVersion(listing, revocation)\n      : listing?.latestVersion\n  if (available == null || available === '') {\n    return {\n      state: 'unknown',\n      installedVersion,\n      availableVersion: null,\n      unknownReason: 'nothing-published',\n    }\n  }\n  const availableVersion = String(available)\n  const order = compareArtifactVersions(installedVersion, availableVersion)\n  if (order === null) {\n    return {\n      state: 'unknown',\n      installedVersion,\n      availableVersion,\n      unknownReason: 'incomparable',\n    }\n  }\n  return {\n    state: order === 0 ? 'current' : order < 0 ? 'update-available' : 'ahead',\n    installedVersion,\n    availableVersion,\n  }\n}\n\n/**\n * One sentence describing an update state, so four surfaces do not each invent\n * their own wording for the same fact.\n */\nexport function updateStateLabel(status: UpdateStatus): string {\n  switch (status.state) {\n    case 'update-available':\n      return `You have v${status.installedVersion} · v${status.availableVersion} available`\n    case 'current':\n      return `Up to date · v${status.installedVersion}`\n    case 'ahead':\n      return `You have v${status.installedVersion}, newer than the published v${status.availableVersion}`\n    default:\n      return status.unknownReason === 'nothing-published'\n        ? 'No published version to compare against'\n        : status.unknownReason === 'incomparable'\n          ? `You have v${status.installedVersion}; v${status.availableVersion} cannot be ordered against it`\n          : 'Installed before update tracking — version unknown'\n  }\n}\n"],"names":["resolveProvenance","offeredPluginVersion","compareArtifactVersions","a","b","left","String","right","parse","value","parts","split","numbers","part","test","push","Number","length","leftParts","rightParts","Math","max","index","leftPart","rightPart","UNKNOWN","state","installedVersion","availableVersion","unknownReason","resolveUpdateState","installed","listing","artifactType","revocation","provenance","version","type","available","latestVersion","order","updateStateLabel","status"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAGD,SAASA,iBAAiB,QAAQ,8BAA0B;AAC5D,SACEC,oBAAoB,QAEf,uBAAmB;AAuC1B;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,wBACdC,CAAqC,EACrCC,CAAqC;IAErC,IAAID,KAAK,QAAQC,KAAK,QAAQD,MAAM,MAAMC,MAAM,IAAI,OAAO;IAC3D,MAAMC,OAAOC,OAAOH;IACpB,MAAMI,QAAQD,OAAOF;IACrB,IAAIC,SAASE,OAAO,OAAO;IAC3B,MAAMC,QAAQ,CAACC;QACb,MAAMC,QAAQD,MAAME,KAAK,CAAC;QAC1B,MAAMC,UAAoB,EAAE;QAC5B,KAAK,MAAMC,QAAQH,MAAO;YACxB,IAAI,CAAC,QAAQI,IAAI,CAACD,OAAO,OAAO;YAChCD,QAAQG,IAAI,CAACC,OAAOH;QACtB;QACA,OAAOD,QAAQK,MAAM,GAAGL,UAAU;IACpC;IACA,MAAMM,YAAYV,MAAMH;IACxB,MAAMc,aAAaX,MAAMD;IACzB,IAAI,CAACW,aAAa,CAACC,YAAY,OAAO;IACtC,MAAMF,SAASG,KAAKC,GAAG,CAACH,UAAUD,MAAM,EAAEE,WAAWF,MAAM;IAC3D,IAAK,IAAIK,QAAQ,GAAGA,QAAQL,QAAQK,SAAS,EAAG;YAC7BJ,kBACCC;QADlB,MAAMI,YAAWL,mBAAAA,SAAS,CAACI,MAAM,YAAhBJ,mBAAoB;QACrC,MAAMM,aAAYL,oBAAAA,UAAU,CAACG,MAAM,YAAjBH,oBAAqB;QACvC,IAAII,WAAWC,WAAW,OAAO,CAAC;QAClC,IAAID,WAAWC,WAAW,OAAO;IACnC;IACA,wEAAwE;IACxE,4BAA4B;IAC5B,OAAO;AACT;AA0BA,MAAMC,UAAwB;IAC5BC,OAAO;IACPC,kBAAkB;IAClBC,kBAAkB;IAClBC,eAAe;AACjB;AAEA;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,SAASC,mBACdC,SAAqD,EACrDC,OAAmD,EACnDC,YAAsC,EACtCC,UAAoC;QAOvBC,MAAAA;IALb,MAAMA,aAAanC,kBAAkB+B,WAAoBE;IACzD,IAAI,CAACF,aAAaI,WAAWT,KAAK,KAAK,aAAa,CAACS,WAAWC,OAAO,EAAE;QACvE,OAAOX;IACT;IACA,MAAME,mBAAmBQ,WAAWC,OAAO;IAC3C,MAAMC,QAAOF,QAAAA,2BAAAA,WAAWF,YAAY,YAAvBE,2BAA2BF,wBAA3BE,OAA2C;IACxD,MAAMG,YACJD,SAAS,WACLpC,qBAAqB+B,SAASE,cAC9BF,2BAAAA,QAASO,aAAa;IAC5B,IAAID,aAAa,QAAQA,cAAc,IAAI;QACzC,OAAO;YACLZ,OAAO;YACPC;YACAC,kBAAkB;YAClBC,eAAe;QACjB;IACF;IACA,MAAMD,mBAAmBtB,OAAOgC;IAChC,MAAME,QAAQtC,wBAAwByB,kBAAkBC;IACxD,IAAIY,UAAU,MAAM;QAClB,OAAO;YACLd,OAAO;YACPC;YACAC;YACAC,eAAe;QACjB;IACF;IACA,OAAO;QACLH,OAAOc,UAAU,IAAI,YAAYA,QAAQ,IAAI,qBAAqB;QAClEb;QACAC;IACF;AACF;AAEA;;;CAGC,GACD,OAAO,SAASa,iBAAiBC,MAAoB;IACnD,OAAQA,OAAOhB,KAAK;QAClB,KAAK;YACH,OAAO,CAAC,UAAU,EAAEgB,OAAOf,gBAAgB,CAAC,IAAI,EAAEe,OAAOd,gBAAgB,CAAC,UAAU,CAAC;QACvF,KAAK;YACH,OAAO,CAAC,cAAc,EAAEc,OAAOf,gBAAgB,EAAE;QACnD,KAAK;YACH,OAAO,CAAC,UAAU,EAAEe,OAAOf,gBAAgB,CAAC,4BAA4B,EAAEe,OAAOd,gBAAgB,EAAE;QACrG;YACE,OAAOc,OAAOb,aAAa,KAAK,sBAC5B,4CACAa,OAAOb,aAAa,KAAK,iBACvB,CAAC,UAAU,EAAEa,OAAOf,gBAAgB,CAAC,GAAG,EAAEe,OAAOd,gBAAgB,CAAC,6BAA6B,CAAC,GAChG;IACV;AACF"}

package/src/lib/app-utils/marketplace-verification.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @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.
+ */
+/**
+ * Who may ask for the Verified badge, and when (AGL-1217).
+ *
+ * In core rather than beside the rest of the marketplace model for the same
+ * reason `marketplace-provenance` is (AGL-1016): the console's staff review
+ * route needs this policy, and `scope:app` may not depend on `aglyn:addons`.
+ * The marketplace model re-exports everything here, so publishing code keeps
+ * importing it from one place.
+ *
+ * A leaf module with no imports — it is reached from the browser, from React
+ * Server Components and from API routes, and every barrel that could carry it
+ * is illegal in at least one of those.
+ */
+export type VerificationRequestState = 'pending' | 'granted' | 'declined' | 'withdrawn';
+/**
+ * Firestore timestamps arrive in two shapes: an SDK `Timestamp` carrying
+ * `toMillis()`, and the plain `{seconds}` object a serialized doc decays into.
+ * Policy has to read both or it silently scores a real date as absent.
+ */
+export type TimestampLike = {
+    toMillis?: () => number;
+    seconds?: number;
+} | null | undefined;
+/** Milliseconds for either timestamp shape; `null` when there is no date. */
+export declare function timestampMs(value: TimestampLike): number | null;
+/**
+ * A publisher's ask for the Verified badge.
+ *
+ * Deliberately NOT a member of `ListingReviewStatus`. That union's
+ * consequential axis is live vs. not live — `listed` is what makes a plugin
+ * installable by every workspace — and a listing can be live *and* awaiting a
+ * verification decision at the same time. A `verification_requested` member
+ * would have to answer "is this live?" and both answers are wrong.
+ *
+ * A record rather than a `verificationRequestedAt` timestamp because
+ * verification may become a paid offering. A timestamp has to be rewritten the
+ * day that lands; this absorbs an order reference without a migration.
+ */
+export interface ListingVerificationRequest {
+    requestedAt?: TimestampLike;
+    /** Publisher uid — a person asked, not "the org asked". */
+    requestedBy?: string;
+    state: VerificationRequestState;
+    decidedAt?: TimestampLike;
+    /** Staff uid, or the publisher's own on a withdrawal. */
+    decidedBy?: string;
+    declineReason?: string;
+    /** Room for a payment reference when verification becomes purchasable. */
+    orderRef?: string;
+}
+/**
+ * How long a publisher waits after a decline before asking again.
+ *
+ * Queue hygiene, not punishment: without it a publisher can re-request in a
+ * loop and staff lose the signal that a request means something changed.
+ */
+export declare const VERIFICATION_DECLINE_COOLDOWN_DAYS = 30;
+/** Why a publisher may not ask right now — `null` when they may. */
+export type VerificationRequestBlock = 'not-publisher' | 'already-verified' | 'not-listed' | 'already-pending' | 'cooling-down';
+/** The listing fields this policy reads, structurally — core cannot see the
+ * marketplace model's `MarketplaceListing`. */
+export interface VerifiableListing {
+    profileId?: string;
+    reviewStatus?: string;
+    verificationRequest?: ListingVerificationRequest;
+}
+/**
+ * A reason rather than a boolean, so the UI can say which and so the server
+ * and the button cannot drift into disagreeing about the rule. Both call this.
+ */
+export declare function verificationRequestBlock(options: {
+    listing: VerifiableListing | null | undefined;
+    /** The org the viewer is acting as. */
+    viewerOrgId: string | null | undefined;
+    /** `Date.now()` on the client; server time on the server. */
+    nowMs: number;
+}): VerificationRequestBlock | null;
+/** What to tell the publisher for each block reason. */
+export declare const VERIFICATION_BLOCK_MESSAGES: Record<VerificationRequestBlock, string>;

package/src/lib/app-utils/marketplace-verification.js

@@ -0,0 +1,81 @@
+/**
+ * @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.
+ */ /**
+ * Who may ask for the Verified badge, and when (AGL-1217).
+ *
+ * In core rather than beside the rest of the marketplace model for the same
+ * reason `marketplace-provenance` is (AGL-1016): the console's staff review
+ * route needs this policy, and `scope:app` may not depend on `aglyn:addons`.
+ * The marketplace model re-exports everything here, so publishing code keeps
+ * importing it from one place.
+ *
+ * A leaf module with no imports — it is reached from the browser, from React
+ * Server Components and from API routes, and every barrel that could carry it
+ * is illegal in at least one of those.
+ */ /** Milliseconds for either timestamp shape; `null` when there is no date. */ export function timestampMs(value) {
+    if (!value) return null;
+    if (typeof value.toMillis === 'function') {
+        const ms = value.toMillis();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    if (typeof value.seconds === 'number') return value.seconds * 1000;
+    return null;
+}
+/**
+ * How long a publisher waits after a decline before asking again.
+ *
+ * Queue hygiene, not punishment: without it a publisher can re-request in a
+ * loop and staff lose the signal that a request means something changed.
+ */ export const VERIFICATION_DECLINE_COOLDOWN_DAYS = 30;
+/**
+ * A reason rather than a boolean, so the UI can say which and so the server
+ * and the button cannot drift into disagreeing about the rule. Both call this.
+ */ export function verificationRequestBlock(options) {
+    const { listing, viewerOrgId, nowMs } = options;
+    if (!listing || !viewerOrgId || listing.profileId !== viewerOrgId) {
+        return 'not-publisher';
+    }
+    if (listing.reviewStatus === 'verified') return 'already-verified';
+    // Only a LIVE listing can be verified. Asking while `submitted`, `in_review`
+    // or `rejected` is asking for a badge on something customers cannot install,
+    // and it would put verification requests into a queue that already has a
+    // different reason to look at the listing.
+    //
+    // A legacy listing with NO status is treated as `listed` elsewhere, but not
+    // here: verification is a deliberate act, and an absent field is not enough
+    // to hang a badge request on.
+    if (listing.reviewStatus !== 'listed') return 'not-listed';
+    const request = listing.verificationRequest;
+    if ((request == null ? void 0 : request.state) === 'pending') return 'already-pending';
+    if ((request == null ? void 0 : request.state) === 'declined') {
+        const decidedAt = timestampMs(request.decidedAt);
+        // Fail closed on an undated decline. Assuming it is old enough turns a
+        // missing field into a free retry, which is what the cooldown prevents.
+        if (decidedAt === null) return 'cooling-down';
+        const elapsedDays = (nowMs - decidedAt) / 86400000;
+        if (elapsedDays < VERIFICATION_DECLINE_COOLDOWN_DAYS) return 'cooling-down';
+    }
+    return null;
+}
+/** What to tell the publisher for each block reason. */ export const VERIFICATION_BLOCK_MESSAGES = {
+    'not-publisher': 'Only the publishing organization can request verification.',
+    'already-verified': 'This listing is already verified.',
+    'not-listed': 'Only a listed plugin can be verified. This one is still going through review.',
+    'already-pending': 'A verification request is already waiting for a decision.',
+    'cooling-down': `Verification was declined recently. You can ask again ${VERIFICATION_DECLINE_COOLDOWN_DAYS} days after the decision.`
+};
+
+//# sourceMappingURL=marketplace-verification.js.map

package/src/lib/app-utils/marketplace-verification.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/marketplace-verification.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 * Who may ask for the Verified badge, and when (AGL-1217).\n *\n * In core rather than beside the rest of the marketplace model for the same\n * reason `marketplace-provenance` is (AGL-1016): the console's staff review\n * route needs this policy, and `scope:app` may not depend on `aglyn:addons`.\n * The marketplace model re-exports everything here, so publishing code keeps\n * importing it from one place.\n *\n * A leaf module with no imports — it is reached from the browser, from React\n * Server Components and from API routes, and every barrel that could carry it\n * is illegal in at least one of those.\n */\n\nexport type VerificationRequestState =\n  | 'pending'\n  | 'granted'\n  | 'declined'\n  | 'withdrawn'\n\n/**\n * Firestore timestamps arrive in two shapes: an SDK `Timestamp` carrying\n * `toMillis()`, and the plain `{seconds}` object a serialized doc decays into.\n * Policy has to read both or it silently scores a real date as absent.\n */\nexport type TimestampLike =\n  | { toMillis?: () => number; seconds?: number }\n  | null\n  | undefined\n\n/** Milliseconds for either timestamp shape; `null` when there is no date. */\nexport function timestampMs(value: TimestampLike): number | null {\n  if (!value) return null\n  if (typeof value.toMillis === 'function') {\n    const ms = value.toMillis()\n    return Number.isFinite(ms) ? ms : null\n  }\n  if (typeof value.seconds === 'number') return value.seconds * 1000\n  return null\n}\n\n/**\n * A publisher's ask for the Verified badge.\n *\n * Deliberately NOT a member of `ListingReviewStatus`. That union's\n * consequential axis is live vs. not live — `listed` is what makes a plugin\n * installable by every workspace — and a listing can be live *and* awaiting a\n * verification decision at the same time. A `verification_requested` member\n * would have to answer \"is this live?\" and both answers are wrong.\n *\n * A record rather than a `verificationRequestedAt` timestamp because\n * verification may become a paid offering. A timestamp has to be rewritten the\n * day that lands; this absorbs an order reference without a migration.\n */\nexport interface ListingVerificationRequest {\n  requestedAt?: TimestampLike\n  /** Publisher uid — a person asked, not \"the org asked\". */\n  requestedBy?: string\n  state: VerificationRequestState\n  decidedAt?: TimestampLike\n  /** Staff uid, or the publisher's own on a withdrawal. */\n  decidedBy?: string\n  declineReason?: string\n  /** Room for a payment reference when verification becomes purchasable. */\n  orderRef?: string\n}\n\n/**\n * How long a publisher waits after a decline before asking again.\n *\n * Queue hygiene, not punishment: without it a publisher can re-request in a\n * loop and staff lose the signal that a request means something changed.\n */\nexport const VERIFICATION_DECLINE_COOLDOWN_DAYS = 30\n\n/** Why a publisher may not ask right now — `null` when they may. */\nexport type VerificationRequestBlock =\n  | 'not-publisher'\n  | 'already-verified'\n  | 'not-listed'\n  | 'already-pending'\n  | 'cooling-down'\n\n/** The listing fields this policy reads, structurally — core cannot see the\n * marketplace model's `MarketplaceListing`. */\nexport interface VerifiableListing {\n  profileId?: string\n  reviewStatus?: string\n  verificationRequest?: ListingVerificationRequest\n}\n\n/**\n * A reason rather than a boolean, so the UI can say which and so the server\n * and the button cannot drift into disagreeing about the rule. Both call this.\n */\nexport function verificationRequestBlock(options: {\n  listing: VerifiableListing | null | undefined\n  /** The org the viewer is acting as. */\n  viewerOrgId: string | null | undefined\n  /** `Date.now()` on the client; server time on the server. */\n  nowMs: number\n}): VerificationRequestBlock | null {\n  const { listing, viewerOrgId, nowMs } = options\n  if (!listing || !viewerOrgId || listing.profileId !== viewerOrgId) {\n    return 'not-publisher'\n  }\n  if (listing.reviewStatus === 'verified') return 'already-verified'\n  // Only a LIVE listing can be verified. Asking while `submitted`, `in_review`\n  // or `rejected` is asking for a badge on something customers cannot install,\n  // and it would put verification requests into a queue that already has a\n  // different reason to look at the listing.\n  //\n  // A legacy listing with NO status is treated as `listed` elsewhere, but not\n  // here: verification is a deliberate act, and an absent field is not enough\n  // to hang a badge request on.\n  if (listing.reviewStatus !== 'listed') return 'not-listed'\n\n  const request = listing.verificationRequest\n  if (request?.state === 'pending') return 'already-pending'\n  if (request?.state === 'declined') {\n    const decidedAt = timestampMs(request.decidedAt)\n    // Fail closed on an undated decline. Assuming it is old enough turns a\n    // missing field into a free retry, which is what the cooldown prevents.\n    if (decidedAt === null) return 'cooling-down'\n    const elapsedDays = (nowMs - decidedAt) / 86_400_000\n    if (elapsedDays < VERIFICATION_DECLINE_COOLDOWN_DAYS) return 'cooling-down'\n  }\n  return null\n}\n\n/** What to tell the publisher for each block reason. */\nexport const VERIFICATION_BLOCK_MESSAGES: Record<\n  VerificationRequestBlock,\n  string\n> = {\n  'not-publisher': 'Only the publishing organization can request verification.',\n  'already-verified': 'This listing is already verified.',\n  'not-listed':\n    'Only a listed plugin can be verified. This one is still going through review.',\n  'already-pending': 'A verification request is already waiting for a decision.',\n  'cooling-down': `Verification was declined recently. You can ask again ${VERIFICATION_DECLINE_COOLDOWN_DAYS} days after the decision.`,\n}\n"],"names":["timestampMs","value","toMillis","ms","Number","isFinite","seconds","VERIFICATION_DECLINE_COOLDOWN_DAYS","verificationRequestBlock","options","listing","viewerOrgId","nowMs","profileId","reviewStatus","request","verificationRequest","state","decidedAt","elapsedDays","VERIFICATION_BLOCK_MESSAGES"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;CAYC,GAkBD,2EAA2E,GAC3E,OAAO,SAASA,YAAYC,KAAoB;IAC9C,IAAI,CAACA,OAAO,OAAO;IACnB,IAAI,OAAOA,MAAMC,QAAQ,KAAK,YAAY;QACxC,MAAMC,KAAKF,MAAMC,QAAQ;QACzB,OAAOE,OAAOC,QAAQ,CAACF,MAAMA,KAAK;IACpC;IACA,IAAI,OAAOF,MAAMK,OAAO,KAAK,UAAU,OAAOL,MAAMK,OAAO,GAAG;IAC9D,OAAO;AACT;AA4BA;;;;;CAKC,GACD,OAAO,MAAMC,qCAAqC,GAAE;AAkBpD;;;CAGC,GACD,OAAO,SAASC,yBAAyBC,OAMxC;IACC,MAAM,EAAEC,OAAO,EAAEC,WAAW,EAAEC,KAAK,EAAE,GAAGH;IACxC,IAAI,CAACC,WAAW,CAACC,eAAeD,QAAQG,SAAS,KAAKF,aAAa;QACjE,OAAO;IACT;IACA,IAAID,QAAQI,YAAY,KAAK,YAAY,OAAO;IAChD,6EAA6E;IAC7E,6EAA6E;IAC7E,yEAAyE;IACzE,2CAA2C;IAC3C,EAAE;IACF,4EAA4E;IAC5E,4EAA4E;IAC5E,8BAA8B;IAC9B,IAAIJ,QAAQI,YAAY,KAAK,UAAU,OAAO;IAE9C,MAAMC,UAAUL,QAAQM,mBAAmB;IAC3C,IAAID,CAAAA,2BAAAA,QAASE,KAAK,MAAK,WAAW,OAAO;IACzC,IAAIF,CAAAA,2BAAAA,QAASE,KAAK,MAAK,YAAY;QACjC,MAAMC,YAAYlB,YAAYe,QAAQG,SAAS;QAC/C,uEAAuE;QACvE,wEAAwE;QACxE,IAAIA,cAAc,MAAM,OAAO;QAC/B,MAAMC,cAAc,AAACP,CAAAA,QAAQM,SAAQ,IAAK;QAC1C,IAAIC,cAAcZ,oCAAoC,OAAO;IAC/D;IACA,OAAO;AACT;AAEA,sDAAsD,GACtD,OAAO,MAAMa,8BAGT;IACF,iBAAiB;IACjB,oBAAoB;IACpB,cACE;IACF,mBAAmB;IACnB,gBAAgB,CAAC,sDAAsD,EAAEb,mCAAmC,yBAAyB,CAAC;AACxI,EAAC"}

package/src/lib/app-utils/measure-node-map.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @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.
+ */
+/** Firestore's hard per-document ceiling. */
+export declare const FIRESTORE_DOC_LIMIT_BYTES = 1048576;
+/**
+ * Refuse above this. Deliberately below the real limit: the encoded node
+ * map is not the only thing in the document, and a save that squeaks under
+ * 1 MiB today fails on the next small edit — which is a worse experience
+ * than being told early.
+ */
+export declare const NODE_MAP_MAX_BYTES = 900000;
+/** Start warning here, while there is still room to act. */
+export declare const NODE_MAP_WARN_BYTES = 700000;
+export interface NodeMapSize {
+    bytes: number;
+    /** Over the refuse threshold. */
+    tooLarge: boolean;
+    /** Past the warn threshold but still saveable. */
+    nearLimit: boolean;
+    /** Node ids by encoded size, largest first — the ones worth looking at. */
+    largest: Array<{
+        id: string;
+        bytes: number;
+    }>;
+}
+/**
+ * Measure a node map the way it will actually be stored (AGL-678).
+ *
+ * Screen and layout versions are msgpack-encoded into a single `Bytes`
+ * field, and nothing checked the result against Firestore's 1 MiB document
+ * limit — so a large enough screen simply stopped saving, with a generic
+ * write rejection, no indication that size was the problem, and no way to
+ * find the offending content except by deleting things and retrying.
+ *
+ * Measures with the same encoder used at rest rather than `JSON.stringify`,
+ * because msgpack is materially denser and a JSON estimate would refuse
+ * documents that would have saved fine.
+ *
+ * Also reports the biggest individual nodes. In practice the cause is one
+ * inlined image data URI rather than a thousand ordinary nodes, and naming
+ * it turns "your page is too big" into something actionable.
+ */
+export declare function measureNodeMap(nodes: Record<string, unknown> | undefined | null): NodeMapSize;
+/**
+ * Encoded size of a node map, and nothing else (AGL-1402).
+ *
+ * Same unit as {@link measureNodeMap} — msgpack bytes, the form the map is
+ * actually stored in — so a total built out of this is directly comparable to
+ * the per-document {@link NODE_MAP_MAX_BYTES} ceiling.
+ *
+ * Split out because the monthly usage rollup measures thousands of documents
+ * and wants one number per document. `measureNodeMap` re-encodes every node
+ * individually to build `largest`, which roughly doubles the work for a
+ * diagnostic that only the save path reads.
+ *
+ * Returns 0 for absent AND for unencodable, matching `measureNodeMap`: a
+ * measurement we could not take must not become a number somebody trusts.
+ */
+export declare function nodeMapBytes(nodes: Record<string, unknown> | undefined | null): number;
+/** Human-readable size, for messages that a person has to act on. */
+export declare function formatBytes(bytes: number): string;
+export default measureNodeMap;

package/src/lib/app-utils/measure-node-map.js

@@ -0,0 +1,111 @@
+/**
+ * @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.
+ */ import { encode } from "@msgpack/msgpack";
+/** Firestore's hard per-document ceiling. */ export const FIRESTORE_DOC_LIMIT_BYTES = 1048576;
+/**
+ * Refuse above this. Deliberately below the real limit: the encoded node
+ * map is not the only thing in the document, and a save that squeaks under
+ * 1 MiB today fails on the next small edit — which is a worse experience
+ * than being told early.
+ */ export const NODE_MAP_MAX_BYTES = 900000;
+/** Start warning here, while there is still room to act. */ export const NODE_MAP_WARN_BYTES = 700000;
+/**
+ * Measure a node map the way it will actually be stored (AGL-678).
+ *
+ * Screen and layout versions are msgpack-encoded into a single `Bytes`
+ * field, and nothing checked the result against Firestore's 1 MiB document
+ * limit — so a large enough screen simply stopped saving, with a generic
+ * write rejection, no indication that size was the problem, and no way to
+ * find the offending content except by deleting things and retrying.
+ *
+ * Measures with the same encoder used at rest rather than `JSON.stringify`,
+ * because msgpack is materially denser and a JSON estimate would refuse
+ * documents that would have saved fine.
+ *
+ * Also reports the biggest individual nodes. In practice the cause is one
+ * inlined image data URI rather than a thousand ordinary nodes, and naming
+ * it turns "your page is too big" into something actionable.
+ */ export function measureNodeMap(nodes) {
+    if (!nodes) {
+        return {
+            bytes: 0,
+            tooLarge: false,
+            nearLimit: false,
+            largest: []
+        };
+    }
+    let bytes;
+    try {
+        bytes = encode(nodes).length;
+    } catch (unused) {
+        // Unencodable content is a different failure; let the write surface it
+        // rather than blocking the save on a measurement we could not take.
+        return {
+            bytes: 0,
+            tooLarge: false,
+            nearLimit: false,
+            largest: []
+        };
+    }
+    const largest = [];
+    for (const [id, node] of Object.entries(nodes)){
+        try {
+            largest.push({
+                id,
+                bytes: encode(node).length
+            });
+        } catch (unused) {
+        // Skip nodes we cannot size; the total above is what gates the save.
+        }
+    }
+    largest.sort((a, b)=>b.bytes - a.bytes);
+    return {
+        bytes,
+        tooLarge: bytes > NODE_MAP_MAX_BYTES,
+        nearLimit: bytes > NODE_MAP_WARN_BYTES && bytes <= NODE_MAP_MAX_BYTES,
+        largest: largest.slice(0, 3)
+    };
+}
+/**
+ * Encoded size of a node map, and nothing else (AGL-1402).
+ *
+ * Same unit as {@link measureNodeMap} — msgpack bytes, the form the map is
+ * actually stored in — so a total built out of this is directly comparable to
+ * the per-document {@link NODE_MAP_MAX_BYTES} ceiling.
+ *
+ * Split out because the monthly usage rollup measures thousands of documents
+ * and wants one number per document. `measureNodeMap` re-encodes every node
+ * individually to build `largest`, which roughly doubles the work for a
+ * diagnostic that only the save path reads.
+ *
+ * Returns 0 for absent AND for unencodable, matching `measureNodeMap`: a
+ * measurement we could not take must not become a number somebody trusts.
+ */ export function nodeMapBytes(nodes) {
+    if (!nodes) return 0;
+    try {
+        return encode(nodes).length;
+    } catch (unused) {
+        return 0;
+    }
+}
+/** Human-readable size, for messages that a person has to act on. */ export function formatBytes(bytes) {
+    if (bytes >= 1000000) return `${(bytes / 1048576).toFixed(1)} MB`;
+    if (bytes >= 1000) return `${Math.round(bytes / 1024)} KB`;
+    return `${bytes} bytes`;
+}
+export default measureNodeMap;
+
+//# sourceMappingURL=measure-node-map.js.map