@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/stored-nodes.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @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.
+ */
+/**
+ * A version document's `nodes` field, decoded to the map every reader wants
+ * (AGL-1223).
+ *
+ * **`nodes` is stored in TWO live forms and both must be handled.** A plain
+ * Firestore map, and msgpack bytes: `screenVersionConverter` compresses on
+ * write (AGL-1151) and decodes only binary payloads on read, because "nodes
+ * saved while updateDoc bypassed the client converter are plain maps rather
+ * than compressed bytes". Server code that reads `snapshot.get('nodes')` raw
+ * therefore gets a Node `Buffer` for the compressed majority.
+ *
+ * That is a SILENT failure, not a loud one, which is why this exists as a
+ * shared helper rather than a note. Every scan predicate in this library
+ * walks the map with `Object.values(nodes)`; over a Buffer that yields the
+ * individual byte NUMBERS, none of which has a `props` or a `componentId`, so
+ * the loop completes and reports no matches. The endpoint answers "used
+ * nowhere" — for `/api/hosts/where-used` an invitation to delete something a
+ * live page renders, and for the media scan the sentence the AGL-1045 scope
+ * confirmation quotes before telling an author it is safe to restrict an
+ * asset.
+ *
+ * Returns `null` for absent AND for undecodable, logging the latter: a caller
+ * skipping a document is the same shape either way, and a decode failure that
+ * threw would fail the whole scan rather than one document.
+ *
+ * Every write path encodes, but the corpus does not: documents written before
+ * a given path learned to are still plain maps and nothing migrates them.
+ * Passing one through here is correct and is the point — a plain map returns
+ * unchanged, so a reader never has to know which it has.
+ *
+ * The bytes arrive as a Node `Buffer` on the server and as a Firestore
+ * `Bytes` on the CLIENT (AGL-1397), and only the first is an `ArrayBuffer`
+ * view. `Bytes` is a wrapper — `decompress` has always accepted it via
+ * `ByteSource`, but this helper used to route only views into `decompress`, so
+ * a `Bytes` fell through to the plain-map branch and came back UNCHANGED.
+ * That is the worst possible outcome for a client caller, because the wrapper
+ * is walkable: its `_byteString.binaryString` is the msgpack payload held as a
+ * latin-1 string, so `rewriteBindingTokensDeep` reads the page's text right
+ * out of the encoded bytes, "normalizes" a token inside them, and hands back
+ * `{_byteString: {binaryString: …}}` for something to write.
+ *
+ * A THIRD form arrives from outside Firestore: `{type: 'Buffer', data: […]}`,
+ * which is what `JSON.stringify` makes of a Node `Buffer` (AGL-1391). Site
+ * export bundles downloaded before that fix carry it, and it is the nastiest
+ * of the three — an `ArrayBuffer` view survives this helper, but a envelope is
+ * a plain object, so without this branch it returns UNCHANGED and every reader
+ * downstream walks an object whose only keys are `type` and `data`.
+ */
+export declare function decodeStoredNodes<T = Record<string, any>>(raw: unknown): T | null;
+/**
+ * Which live storage form a `nodes` field is in.
+ *
+ * `absent` covers both "no field" and a scalar, because the only two things a
+ * caller does with either are skip the document or write a fresh tree.
+ */
+export type StoredNodesForm = 'bytes' | 'map' | 'absent';
+/**
+ * Read the form off a stored field, so a partial update can write back the
+ * way the document came out.
+ *
+ * Rewriting a compressed document as a plain map inflates it by roughly 1.4x,
+ * which is the whole hazard this module exists to keep away from Firestore's
+ * per-document ceiling. A writer that merges one field into a document it did
+ * not fully read has no business changing the encoding of another.
+ *
+ * Recognises every form {@link decodeStoredNodes} does, and answers from the
+ * same predicates, so "what form is this" and "how do I read it" can never
+ * drift apart.
+ */
+export declare function storedNodesForm(raw: unknown): StoredNodesForm;
+/**
+ * A node map in the form it should be STORED in — msgpack bytes.
+ *
+ * The write-side twin of {@link decodeStoredNodes}, and deliberately in the
+ * same file: a reader who finds one finds the other, which is what stops the
+ * next write path from being added without an encoding.
+ *
+ * Returns a bare `Uint8Array` and knows NOTHING about Firestore, for the
+ * reason `compress` documents — one value import of the client SDK's `Bytes`
+ * pulls the whole Firestore client into the tenant bundle. The caller wraps:
+ * `Bytes.fromUint8Array(...)` on the client SDK, `Buffer.from(...)` on the
+ * Admin SDK, which is what each accepts for a bytes field.
+ *
+ * ALREADY-encoded input passes through rather than being encoded again. A
+ * write path that copies a stored document — a version snapshot, an install
+ * from a published artifact — receives whichever form that document held, and
+ * msgpack of msgpack is a tree no reader can decode.
+ *
+ * Returns `null` for an absent field, so a caller can omit the key entirely
+ * rather than writing an empty map over a real tree (AGL-1250).
+ */
+export declare function encodeStoredNodes(nodes: unknown): Uint8Array | null;
+/**
+ * The tree in the form the document already used.
+ *
+ * For the partial-update case: a writer that changes one field of a document
+ * it did not create must not also change how `nodes` is encoded. Pass the
+ * form read off the stored field and this hands back something to write.
+ *
+ * `absent` encodes, because a document with no stored form yet is a new one
+ * and new documents are compressed.
+ */
+export declare function matchStoredNodesForm<T>(nodes: T, form: StoredNodesForm): Uint8Array | T | null;
+export default decodeStoredNodes;

package/src/lib/app-utils/stored-nodes.js

@@ -0,0 +1,174 @@
+/**
+ * @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 { compress } from "./compress.js";
+import { decompress } from "./decompress.js";
+/**
+ * A version document's `nodes` field, decoded to the map every reader wants
+ * (AGL-1223).
+ *
+ * **`nodes` is stored in TWO live forms and both must be handled.** A plain
+ * Firestore map, and msgpack bytes: `screenVersionConverter` compresses on
+ * write (AGL-1151) and decodes only binary payloads on read, because "nodes
+ * saved while updateDoc bypassed the client converter are plain maps rather
+ * than compressed bytes". Server code that reads `snapshot.get('nodes')` raw
+ * therefore gets a Node `Buffer` for the compressed majority.
+ *
+ * That is a SILENT failure, not a loud one, which is why this exists as a
+ * shared helper rather than a note. Every scan predicate in this library
+ * walks the map with `Object.values(nodes)`; over a Buffer that yields the
+ * individual byte NUMBERS, none of which has a `props` or a `componentId`, so
+ * the loop completes and reports no matches. The endpoint answers "used
+ * nowhere" — for `/api/hosts/where-used` an invitation to delete something a
+ * live page renders, and for the media scan the sentence the AGL-1045 scope
+ * confirmation quotes before telling an author it is safe to restrict an
+ * asset.
+ *
+ * Returns `null` for absent AND for undecodable, logging the latter: a caller
+ * skipping a document is the same shape either way, and a decode failure that
+ * threw would fail the whole scan rather than one document.
+ *
+ * Every write path encodes, but the corpus does not: documents written before
+ * a given path learned to are still plain maps and nothing migrates them.
+ * Passing one through here is correct and is the point — a plain map returns
+ * unchanged, so a reader never has to know which it has.
+ *
+ * The bytes arrive as a Node `Buffer` on the server and as a Firestore
+ * `Bytes` on the CLIENT (AGL-1397), and only the first is an `ArrayBuffer`
+ * view. `Bytes` is a wrapper — `decompress` has always accepted it via
+ * `ByteSource`, but this helper used to route only views into `decompress`, so
+ * a `Bytes` fell through to the plain-map branch and came back UNCHANGED.
+ * That is the worst possible outcome for a client caller, because the wrapper
+ * is walkable: its `_byteString.binaryString` is the msgpack payload held as a
+ * latin-1 string, so `rewriteBindingTokensDeep` reads the page's text right
+ * out of the encoded bytes, "normalizes" a token inside them, and hands back
+ * `{_byteString: {binaryString: …}}` for something to write.
+ *
+ * A THIRD form arrives from outside Firestore: `{type: 'Buffer', data: […]}`,
+ * which is what `JSON.stringify` makes of a Node `Buffer` (AGL-1391). Site
+ * export bundles downloaded before that fix carry it, and it is the nastiest
+ * of the three — an `ArrayBuffer` view survives this helper, but a envelope is
+ * a plain object, so without this branch it returns UNCHANGED and every reader
+ * downstream walks an object whose only keys are `type` and `data`.
+ */ export function decodeStoredNodes(raw) {
+    var _byteSource;
+    if (raw === null || raw === undefined) return null;
+    const bytes = ArrayBuffer.isView(raw) ? raw : (_byteSource = byteSource(raw)) != null ? _byteSource : bufferEnvelopeBytes(raw);
+    if (bytes) {
+        try {
+            return decompress(bytes);
+        } catch (error) {
+            // Undecodable nodes must never read as "no references".
+            console.error('could not decode stored nodes', error);
+            return null;
+        }
+    }
+    return raw;
+}
+/**
+ * Read the form off a stored field, so a partial update can write back the
+ * way the document came out.
+ *
+ * Rewriting a compressed document as a plain map inflates it by roughly 1.4x,
+ * which is the whole hazard this module exists to keep away from Firestore's
+ * per-document ceiling. A writer that merges one field into a document it did
+ * not fully read has no business changing the encoding of another.
+ *
+ * Recognises every form {@link decodeStoredNodes} does, and answers from the
+ * same predicates, so "what form is this" and "how do I read it" can never
+ * drift apart.
+ */ export function storedNodesForm(raw) {
+    if (raw === null || raw === undefined) return 'absent';
+    if (ArrayBuffer.isView(raw)) return 'bytes';
+    if (typeof raw !== 'object') return 'absent';
+    if (byteSource(raw) || bufferEnvelopeBytes(raw)) return 'bytes';
+    return 'map';
+}
+/**
+ * A node map in the form it should be STORED in — msgpack bytes.
+ *
+ * The write-side twin of {@link decodeStoredNodes}, and deliberately in the
+ * same file: a reader who finds one finds the other, which is what stops the
+ * next write path from being added without an encoding.
+ *
+ * Returns a bare `Uint8Array` and knows NOTHING about Firestore, for the
+ * reason `compress` documents — one value import of the client SDK's `Bytes`
+ * pulls the whole Firestore client into the tenant bundle. The caller wraps:
+ * `Bytes.fromUint8Array(...)` on the client SDK, `Buffer.from(...)` on the
+ * Admin SDK, which is what each accepts for a bytes field.
+ *
+ * ALREADY-encoded input passes through rather than being encoded again. A
+ * write path that copies a stored document — a version snapshot, an install
+ * from a published artifact — receives whichever form that document held, and
+ * msgpack of msgpack is a tree no reader can decode.
+ *
+ * Returns `null` for an absent field, so a caller can omit the key entirely
+ * rather than writing an empty map over a real tree (AGL-1250).
+ */ export function encodeStoredNodes(nodes) {
+    if (nodes === null || nodes === undefined) return null;
+    if (ArrayBuffer.isView(nodes)) {
+        // Offset and length, for the reason `decompress` documents: firebase-admin
+        // hands back POOLED Buffers, so the whole backing ArrayBuffer is usually
+        // somebody else's data.
+        return new Uint8Array(nodes.buffer, nodes.byteOffset, nodes.byteLength);
+    }
+    if (typeof nodes !== 'object') return null;
+    const source = byteSource(nodes);
+    if (source) return source.toUint8Array();
+    const envelope = bufferEnvelopeBytes(nodes);
+    if (envelope) return envelope;
+    return compress(nodes);
+}
+/**
+ * The tree in the form the document already used.
+ *
+ * For the partial-update case: a writer that changes one field of a document
+ * it did not create must not also change how `nodes` is encoded. Pass the
+ * form read off the stored field and this hands back something to write.
+ *
+ * `absent` encodes, because a document with no stored form yet is a new one
+ * and new documents are compressed.
+ */ export function matchStoredNodesForm(nodes, form) {
+    return form === 'map' ? nodes : encodeStoredNodes(nodes);
+}
+/**
+ * The client SDK's `Bytes`, structurally, or `null` for anything else.
+ *
+ * Matched on the method rather than the class so `firebase/firestore` stays
+ * out of this library — the same reason `decompress` types its input as
+ * `ByteSource`. A node map cannot collide: its values are node OBJECTS, never
+ * functions.
+ */ function byteSource(raw) {
+    if (typeof raw !== 'object') return null;
+    return typeof raw.toUint8Array === 'function' ? raw : null;
+}
+/**
+ * A JSON-serialized Node `Buffer`, or `null` for anything else.
+ *
+ * The test is deliberately exact — `type === 'Buffer'`, an array `data`, and
+ * NOTHING else — because the alternative reading of this object is a node map
+ * with nodes called `type` and `data`. That map cannot exist: a node map's
+ * values are node objects, so `type` would have to hold the literal string
+ * `'Buffer'` and `data` an array, at the same time, in the same document.
+ */ function bufferEnvelopeBytes(raw) {
+    if (typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const value = raw;
+    if (value.type !== 'Buffer' || !Array.isArray(value.data)) return null;
+    if (Object.keys(value).length !== 2) return null;
+    return Uint8Array.from(value.data);
+}
+export default decodeStoredNodes;
+
+//# sourceMappingURL=stored-nodes.js.map

package/src/lib/app-utils/stored-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/stored-nodes.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 { compress } from './compress'\nimport { decompress, type ByteSource } from './decompress'\n\n/**\n * A version document's `nodes` field, decoded to the map every reader wants\n * (AGL-1223).\n *\n * **`nodes` is stored in TWO live forms and both must be handled.** A plain\n * Firestore map, and msgpack bytes: `screenVersionConverter` compresses on\n * write (AGL-1151) and decodes only binary payloads on read, because \"nodes\n * saved while updateDoc bypassed the client converter are plain maps rather\n * than compressed bytes\". Server code that reads `snapshot.get('nodes')` raw\n * therefore gets a Node `Buffer` for the compressed majority.\n *\n * That is a SILENT failure, not a loud one, which is why this exists as a\n * shared helper rather than a note. Every scan predicate in this library\n * walks the map with `Object.values(nodes)`; over a Buffer that yields the\n * individual byte NUMBERS, none of which has a `props` or a `componentId`, so\n * the loop completes and reports no matches. The endpoint answers \"used\n * nowhere\" — for `/api/hosts/where-used` an invitation to delete something a\n * live page renders, and for the media scan the sentence the AGL-1045 scope\n * confirmation quotes before telling an author it is safe to restrict an\n * asset.\n *\n * Returns `null` for absent AND for undecodable, logging the latter: a caller\n * skipping a document is the same shape either way, and a decode failure that\n * threw would fail the whole scan rather than one document.\n *\n * Every write path encodes, but the corpus does not: documents written before\n * a given path learned to are still plain maps and nothing migrates them.\n * Passing one through here is correct and is the point — a plain map returns\n * unchanged, so a reader never has to know which it has.\n *\n * The bytes arrive as a Node `Buffer` on the server and as a Firestore\n * `Bytes` on the CLIENT (AGL-1397), and only the first is an `ArrayBuffer`\n * view. `Bytes` is a wrapper — `decompress` has always accepted it via\n * `ByteSource`, but this helper used to route only views into `decompress`, so\n * a `Bytes` fell through to the plain-map branch and came back UNCHANGED.\n * That is the worst possible outcome for a client caller, because the wrapper\n * is walkable: its `_byteString.binaryString` is the msgpack payload held as a\n * latin-1 string, so `rewriteBindingTokensDeep` reads the page's text right\n * out of the encoded bytes, \"normalizes\" a token inside them, and hands back\n * `{_byteString: {binaryString: …}}` for something to write.\n *\n * A THIRD form arrives from outside Firestore: `{type: 'Buffer', data: […]}`,\n * which is what `JSON.stringify` makes of a Node `Buffer` (AGL-1391). Site\n * export bundles downloaded before that fix carry it, and it is the nastiest\n * of the three — an `ArrayBuffer` view survives this helper, but a envelope is\n * a plain object, so without this branch it returns UNCHANGED and every reader\n * downstream walks an object whose only keys are `type` and `data`.\n */\nexport function decodeStoredNodes<T = Record<string, any>>(\n  raw: unknown,\n): T | null {\n  if (raw === null || raw === undefined) return null\n  const bytes = ArrayBuffer.isView(raw)\n    ? raw\n    : byteSource(raw) ?? bufferEnvelopeBytes(raw)\n  if (bytes) {\n    try {\n      return decompress<T>(bytes)\n    } catch (error) {\n      // Undecodable nodes must never read as \"no references\".\n      console.error('could not decode stored nodes', error)\n      return null\n    }\n  }\n  return raw as T\n}\n\n/**\n * Which live storage form a `nodes` field is in.\n *\n * `absent` covers both \"no field\" and a scalar, because the only two things a\n * caller does with either are skip the document or write a fresh tree.\n */\nexport type StoredNodesForm = 'bytes' | 'map' | 'absent'\n\n/**\n * Read the form off a stored field, so a partial update can write back the\n * way the document came out.\n *\n * Rewriting a compressed document as a plain map inflates it by roughly 1.4x,\n * which is the whole hazard this module exists to keep away from Firestore's\n * per-document ceiling. A writer that merges one field into a document it did\n * not fully read has no business changing the encoding of another.\n *\n * Recognises every form {@link decodeStoredNodes} does, and answers from the\n * same predicates, so \"what form is this\" and \"how do I read it\" can never\n * drift apart.\n */\nexport function storedNodesForm(raw: unknown): StoredNodesForm {\n  if (raw === null || raw === undefined) return 'absent'\n  if (ArrayBuffer.isView(raw)) return 'bytes'\n  if (typeof raw !== 'object') return 'absent'\n  if (byteSource(raw) || bufferEnvelopeBytes(raw)) return 'bytes'\n  return 'map'\n}\n\n/**\n * A node map in the form it should be STORED in — msgpack bytes.\n *\n * The write-side twin of {@link decodeStoredNodes}, and deliberately in the\n * same file: a reader who finds one finds the other, which is what stops the\n * next write path from being added without an encoding.\n *\n * Returns a bare `Uint8Array` and knows NOTHING about Firestore, for the\n * reason `compress` documents — one value import of the client SDK's `Bytes`\n * pulls the whole Firestore client into the tenant bundle. The caller wraps:\n * `Bytes.fromUint8Array(...)` on the client SDK, `Buffer.from(...)` on the\n * Admin SDK, which is what each accepts for a bytes field.\n *\n * ALREADY-encoded input passes through rather than being encoded again. A\n * write path that copies a stored document — a version snapshot, an install\n * from a published artifact — receives whichever form that document held, and\n * msgpack of msgpack is a tree no reader can decode.\n *\n * Returns `null` for an absent field, so a caller can omit the key entirely\n * rather than writing an empty map over a real tree (AGL-1250).\n */\nexport function encodeStoredNodes(nodes: unknown): Uint8Array | null {\n  if (nodes === null || nodes === undefined) return null\n  if (ArrayBuffer.isView(nodes)) {\n    // Offset and length, for the reason `decompress` documents: firebase-admin\n    // hands back POOLED Buffers, so the whole backing ArrayBuffer is usually\n    // somebody else's data.\n    return new Uint8Array(nodes.buffer, nodes.byteOffset, nodes.byteLength)\n  }\n  if (typeof nodes !== 'object') return null\n  const source = byteSource(nodes)\n  if (source) return source.toUint8Array()\n  const envelope = bufferEnvelopeBytes(nodes)\n  if (envelope) return envelope\n  return compress(nodes)\n}\n\n/**\n * The tree in the form the document already used.\n *\n * For the partial-update case: a writer that changes one field of a document\n * it did not create must not also change how `nodes` is encoded. Pass the\n * form read off the stored field and this hands back something to write.\n *\n * `absent` encodes, because a document with no stored form yet is a new one\n * and new documents are compressed.\n */\nexport function matchStoredNodesForm<T>(\n  nodes: T,\n  form: StoredNodesForm,\n): Uint8Array | T | null {\n  return form === 'map' ? nodes : encodeStoredNodes(nodes)\n}\n\n/**\n * The client SDK's `Bytes`, structurally, or `null` for anything else.\n *\n * Matched on the method rather than the class so `firebase/firestore` stays\n * out of this library — the same reason `decompress` types its input as\n * `ByteSource`. A node map cannot collide: its values are node OBJECTS, never\n * functions.\n */\nfunction byteSource(raw: unknown): ByteSource | null {\n  if (typeof raw !== 'object') return null\n  return typeof (raw as ByteSource).toUint8Array === 'function'\n    ? (raw as ByteSource)\n    : null\n}\n\n/**\n * A JSON-serialized Node `Buffer`, or `null` for anything else.\n *\n * The test is deliberately exact — `type === 'Buffer'`, an array `data`, and\n * NOTHING else — because the alternative reading of this object is a node map\n * with nodes called `type` and `data`. That map cannot exist: a node map's\n * values are node objects, so `type` would have to hold the literal string\n * `'Buffer'` and `data` an array, at the same time, in the same document.\n */\nfunction bufferEnvelopeBytes(raw: unknown): Uint8Array | null {\n  if (typeof raw !== 'object' || Array.isArray(raw)) return null\n  const value = raw as { type?: unknown; data?: unknown }\n  if (value.type !== 'Buffer' || !Array.isArray(value.data)) return null\n  if (Object.keys(value).length !== 2) return null\n  return Uint8Array.from(value.data as number[])\n}\n\nexport default decodeStoredNodes\n"],"names":["compress","decompress","decodeStoredNodes","raw","byteSource","undefined","bytes","ArrayBuffer","isView","bufferEnvelopeBytes","error","console","storedNodesForm","encodeStoredNodes","nodes","Uint8Array","buffer","byteOffset","byteLength","source","toUint8Array","envelope","matchStoredNodesForm","form","Array","isArray","value","type","data","Object","keys","length","from"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,QAAQ,QAAQ,gBAAY;AACrC,SAASC,UAAU,QAAyB,kBAAc;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CC,GACD,OAAO,SAASC,kBACdC,GAAY;QAKRC;IAHJ,IAAID,QAAQ,QAAQA,QAAQE,WAAW,OAAO;IAC9C,MAAMC,QAAQC,YAAYC,MAAM,CAACL,OAC7BA,OACAC,cAAAA,WAAWD,gBAAXC,cAAmBK,oBAAoBN;IAC3C,IAAIG,OAAO;QACT,IAAI;YACF,OAAOL,WAAcK;QACvB,EAAE,OAAOI,OAAO;YACd,wDAAwD;YACxDC,QAAQD,KAAK,CAAC,iCAAiCA;YAC/C,OAAO;QACT;IACF;IACA,OAAOP;AACT;AAUA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASS,gBAAgBT,GAAY;IAC1C,IAAIA,QAAQ,QAAQA,QAAQE,WAAW,OAAO;IAC9C,IAAIE,YAAYC,MAAM,CAACL,MAAM,OAAO;IACpC,IAAI,OAAOA,QAAQ,UAAU,OAAO;IACpC,IAAIC,WAAWD,QAAQM,oBAAoBN,MAAM,OAAO;IACxD,OAAO;AACT;AAEA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASU,kBAAkBC,KAAc;IAC9C,IAAIA,UAAU,QAAQA,UAAUT,WAAW,OAAO;IAClD,IAAIE,YAAYC,MAAM,CAACM,QAAQ;QAC7B,2EAA2E;QAC3E,yEAAyE;QACzE,wBAAwB;QACxB,OAAO,IAAIC,WAAWD,MAAME,MAAM,EAAEF,MAAMG,UAAU,EAAEH,MAAMI,UAAU;IACxE;IACA,IAAI,OAAOJ,UAAU,UAAU,OAAO;IACtC,MAAMK,SAASf,WAAWU;IAC1B,IAAIK,QAAQ,OAAOA,OAAOC,YAAY;IACtC,MAAMC,WAAWZ,oBAAoBK;IACrC,IAAIO,UAAU,OAAOA;IACrB,OAAOrB,SAASc;AAClB;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASQ,qBACdR,KAAQ,EACRS,IAAqB;IAErB,OAAOA,SAAS,QAAQT,QAAQD,kBAAkBC;AACpD;AAEA;;;;;;;CAOC,GACD,SAASV,WAAWD,GAAY;IAC9B,IAAI,OAAOA,QAAQ,UAAU,OAAO;IACpC,OAAO,OAAO,AAACA,IAAmBiB,YAAY,KAAK,aAC9CjB,MACD;AACN;AAEA;;;;;;;;CAQC,GACD,SAASM,oBAAoBN,GAAY;IACvC,IAAI,OAAOA,QAAQ,YAAYqB,MAAMC,OAAO,CAACtB,MAAM,OAAO;IAC1D,MAAMuB,QAAQvB;IACd,IAAIuB,MAAMC,IAAI,KAAK,YAAY,CAACH,MAAMC,OAAO,CAACC,MAAME,IAAI,GAAG,OAAO;IAClE,IAAIC,OAAOC,IAAI,CAACJ,OAAOK,MAAM,KAAK,GAAG,OAAO;IAC5C,OAAOhB,WAAWiB,IAAI,CAACN,MAAME,IAAI;AACnC;AAEA,eAAe1B,kBAAiB"}

package/src/lib/app-utils/strip-undefined.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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.
+ */
+/**
+ * Remove every `undefined` value from a serialized node payload (AGL-1334).
+ *
+ * An editor form hands back its whole field set, so an optional attribute the
+ * author never set — or cleared — arrives as an OWN key whose value is
+ * `undefined` (the icon pickers do exactly this: `startIconPath` is written on
+ * every edit of a Button whose Start icon reads `(NONE)`). `undefined` is not
+ * a storable value, and the two besigner write paths disagreed about it in the
+ * worst possible way:
+ *
+ * - A **save** goes through a version-doc converter that msgpack-encodes the
+ *   node map, and msgpack encodes an `undefined` member as nil — so the write
+ *   succeeded and quietly persisted `startIconPath: null`. That null is the
+ *   exact shape `dropClearedProps` has to defend against at RENDER time
+ *   (AGL-1226), where it once 500'd every `/product/*` page.
+ * - A **publish** copies the same map onto the component document as a plain
+ *   Firestore map, and `updateDoc()` rejects `undefined` outright:
+ *   `Unsupported field value: undefined (found in field nodes.<id>.props.…)`.
+ *
+ * So the author saved, saw `UP TO DATE`, clicked Publish, and got a raw
+ * Firestore error — with every instance still rendering the old markup.
+ *
+ * Dropping the key is what "cleared" means for an optional prop: absent, so
+ * the component's own default applies. Not `null`, which is a value, and not
+ * `deleteField()`, which cannot appear inside a nested map written wholesale.
+ * Applied at the ONE place both write paths serialize from
+ * (`AglynNode.toJSON`), so save and publish agree by construction rather than
+ * by two strippers that can drift.
+ *
+ * `null`, `0`, `''` and `false` are kept — those are values an author can mean
+ * (and, unlike `undefined`, all four store fine).
+ *
+ * Recurses into plain objects and arrays only: a `Date`, a Firestore
+ * `Timestamp`, a `Bytes` or any other class instance is a leaf and is passed
+ * through untouched. An `undefined` array ELEMENT is dropped rather than
+ * held as a hole, because Firestore rejects those too and a node's arrays are
+ * id lists and sx layers, where a hole means nothing.
+ *
+ * Returns the input by reference when there is nothing to strip, so the common
+ * case allocates nothing and identity-based memoization is undisturbed.
+ */
+export declare function stripUndefinedDeep<T>(value: T): T;
+export default stripUndefinedDeep;

package/src/lib/app-utils/strip-undefined.js

@@ -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.
+ */ const isPlainObject = (value)=>{
+    if (typeof value !== 'object' || value === null) return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+/**
+ * Remove every `undefined` value from a serialized node payload (AGL-1334).
+ *
+ * An editor form hands back its whole field set, so an optional attribute the
+ * author never set — or cleared — arrives as an OWN key whose value is
+ * `undefined` (the icon pickers do exactly this: `startIconPath` is written on
+ * every edit of a Button whose Start icon reads `(NONE)`). `undefined` is not
+ * a storable value, and the two besigner write paths disagreed about it in the
+ * worst possible way:
+ *
+ * - A **save** goes through a version-doc converter that msgpack-encodes the
+ *   node map, and msgpack encodes an `undefined` member as nil — so the write
+ *   succeeded and quietly persisted `startIconPath: null`. That null is the
+ *   exact shape `dropClearedProps` has to defend against at RENDER time
+ *   (AGL-1226), where it once 500'd every `/product/*` page.
+ * - A **publish** copies the same map onto the component document as a plain
+ *   Firestore map, and `updateDoc()` rejects `undefined` outright:
+ *   `Unsupported field value: undefined (found in field nodes.<id>.props.…)`.
+ *
+ * So the author saved, saw `UP TO DATE`, clicked Publish, and got a raw
+ * Firestore error — with every instance still rendering the old markup.
+ *
+ * Dropping the key is what "cleared" means for an optional prop: absent, so
+ * the component's own default applies. Not `null`, which is a value, and not
+ * `deleteField()`, which cannot appear inside a nested map written wholesale.
+ * Applied at the ONE place both write paths serialize from
+ * (`AglynNode.toJSON`), so save and publish agree by construction rather than
+ * by two strippers that can drift.
+ *
+ * `null`, `0`, `''` and `false` are kept — those are values an author can mean
+ * (and, unlike `undefined`, all four store fine).
+ *
+ * Recurses into plain objects and arrays only: a `Date`, a Firestore
+ * `Timestamp`, a `Bytes` or any other class instance is a leaf and is passed
+ * through untouched. An `undefined` array ELEMENT is dropped rather than
+ * held as a hole, because Firestore rejects those too and a node's arrays are
+ * id lists and sx layers, where a hole means nothing.
+ *
+ * Returns the input by reference when there is nothing to strip, so the common
+ * case allocates nothing and identity-based memoization is undisturbed.
+ */ export function stripUndefinedDeep(value) {
+    if (Array.isArray(value)) {
+        let changed = false;
+        const next = [];
+        for (const item of value){
+            if (item === undefined) {
+                changed = true;
+                continue;
+            }
+            const stripped = stripUndefinedDeep(item);
+            if (stripped !== item) changed = true;
+            next.push(stripped);
+        }
+        return changed ? next : value;
+    }
+    if (isPlainObject(value)) {
+        let changed = false;
+        const next = {};
+        for (const key of Object.keys(value)){
+            const item = value[key];
+            if (item === undefined) {
+                changed = true;
+                continue;
+            }
+            const stripped = stripUndefinedDeep(item);
+            if (stripped !== item) changed = true;
+            next[key] = stripped;
+        }
+        return changed ? next : value;
+    }
+    return value;
+}
+export default stripUndefinedDeep;
+
+//# sourceMappingURL=strip-undefined.js.map

package/src/lib/app-utils/strip-undefined.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/strip-undefined.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\nconst isPlainObject = (value: unknown): value is Record<string, unknown> => {\n  if (typeof value !== 'object' || value === null) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\n/**\n * Remove every `undefined` value from a serialized node payload (AGL-1334).\n *\n * An editor form hands back its whole field set, so an optional attribute the\n * author never set — or cleared — arrives as an OWN key whose value is\n * `undefined` (the icon pickers do exactly this: `startIconPath` is written on\n * every edit of a Button whose Start icon reads `(NONE)`). `undefined` is not\n * a storable value, and the two besigner write paths disagreed about it in the\n * worst possible way:\n *\n * - A **save** goes through a version-doc converter that msgpack-encodes the\n *   node map, and msgpack encodes an `undefined` member as nil — so the write\n *   succeeded and quietly persisted `startIconPath: null`. That null is the\n *   exact shape `dropClearedProps` has to defend against at RENDER time\n *   (AGL-1226), where it once 500'd every `/product/*` page.\n * - A **publish** copies the same map onto the component document as a plain\n *   Firestore map, and `updateDoc()` rejects `undefined` outright:\n *   `Unsupported field value: undefined (found in field nodes.<id>.props.…)`.\n *\n * So the author saved, saw `UP TO DATE`, clicked Publish, and got a raw\n * Firestore error — with every instance still rendering the old markup.\n *\n * Dropping the key is what \"cleared\" means for an optional prop: absent, so\n * the component's own default applies. Not `null`, which is a value, and not\n * `deleteField()`, which cannot appear inside a nested map written wholesale.\n * Applied at the ONE place both write paths serialize from\n * (`AglynNode.toJSON`), so save and publish agree by construction rather than\n * by two strippers that can drift.\n *\n * `null`, `0`, `''` and `false` are kept — those are values an author can mean\n * (and, unlike `undefined`, all four store fine).\n *\n * Recurses into plain objects and arrays only: a `Date`, a Firestore\n * `Timestamp`, a `Bytes` or any other class instance is a leaf and is passed\n * through untouched. An `undefined` array ELEMENT is dropped rather than\n * held as a hole, because Firestore rejects those too and a node's arrays are\n * id lists and sx layers, where a hole means nothing.\n *\n * Returns the input by reference when there is nothing to strip, so the common\n * case allocates nothing and identity-based memoization is undisturbed.\n */\nexport function stripUndefinedDeep<T>(value: T): T {\n  if (Array.isArray(value)) {\n    let changed = false\n    const next: unknown[] = []\n    for (const item of value) {\n      if (item === undefined) {\n        changed = true\n        continue\n      }\n      const stripped = stripUndefinedDeep(item)\n      if (stripped !== item) changed = true\n      next.push(stripped)\n    }\n    return (changed ? next : value) as T\n  }\n\n  if (isPlainObject(value)) {\n    let changed = false\n    const next: Record<string, unknown> = {}\n    for (const key of Object.keys(value)) {\n      const item = value[key]\n      if (item === undefined) {\n        changed = true\n        continue\n      }\n      const stripped = stripUndefinedDeep(item)\n      if (stripped !== item) changed = true\n      next[key] = stripped\n    }\n    return (changed ? next : value) as T\n  }\n\n  return value\n}\n\nexport default stripUndefinedDeep\n"],"names":["isPlainObject","value","proto","Object","getPrototypeOf","prototype","stripUndefinedDeep","Array","isArray","changed","next","item","undefined","stripped","push","key","keys"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,MAAMA,gBAAgB,CAACC;IACrB,IAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM,OAAO;IACxD,MAAMC,QAAQC,OAAOC,cAAc,CAACH;IACpC,OAAOC,UAAUC,OAAOE,SAAS,IAAIH,UAAU;AACjD;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCC,GACD,OAAO,SAASI,mBAAsBL,KAAQ;IAC5C,IAAIM,MAAMC,OAAO,CAACP,QAAQ;QACxB,IAAIQ,UAAU;QACd,MAAMC,OAAkB,EAAE;QAC1B,KAAK,MAAMC,QAAQV,MAAO;YACxB,IAAIU,SAASC,WAAW;gBACtBH,UAAU;gBACV;YACF;YACA,MAAMI,WAAWP,mBAAmBK;YACpC,IAAIE,aAAaF,MAAMF,UAAU;YACjCC,KAAKI,IAAI,CAACD;QACZ;QACA,OAAQJ,UAAUC,OAAOT;IAC3B;IAEA,IAAID,cAAcC,QAAQ;QACxB,IAAIQ,UAAU;QACd,MAAMC,OAAgC,CAAC;QACvC,KAAK,MAAMK,OAAOZ,OAAOa,IAAI,CAACf,OAAQ;YACpC,MAAMU,OAAOV,KAAK,CAACc,IAAI;YACvB,IAAIJ,SAASC,WAAW;gBACtBH,UAAU;gBACV;YACF;YACA,MAAMI,WAAWP,mBAAmBK;YACpC,IAAIE,aAAaF,MAAMF,UAAU;YACjCC,IAAI,CAACK,IAAI,GAAGF;QACd;QACA,OAAQJ,UAAUC,OAAOT;IAC3B;IAEA,OAAOA;AACT;AAEA,eAAeK,mBAAkB"}

package/src/lib/app-utils/stripe-deployment-mode.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @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.
+ */
+/**
+ * Whether THIS deployment is the live one.
+ *
+ * Derived from `STRIPE_SECRET_KEY`'s prefix, with an explicit
+ * `STRIPE_LIVEMODE=true|false` override that wins when set. Note the
+ * asymmetry, which is deliberate: only `sk_live_` yields `true`. An unset or
+ * unrecognised key is NOT a live deployment, because a deployment with no
+ * Stripe secret key cannot be charging anyone.
+ */
+export declare function deploymentLivemode(env?: Partial<Record<string, string>>): boolean;
+/**
+ * Whether a Stripe object id belongs to TEST mode.
+ *
+ * Stripe stamps the environment into the id itself — `cs_test_…`, `pi_test_…`,
+ * `in_test_…` — and that is the only signal a stored document carries when
+ * nothing recorded `livemode` beside it.
+ *
+ * ONE NAMED PLACE, and that is the point of the function rather than a
+ * `.startsWith()` at each call site. This is STRIPE'S convention, not our
+ * data: it is a fact about a third party's id format that we happen to depend
+ * on, so it needs somewhere to be documented, somewhere to be changed, and
+ * somewhere a reader can find every consumer of it. A recorded `livemode`
+ * beats it and callers should prefer one; this is the fallback for documents
+ * written before anything recorded the fact.
+ *
+ * Strict prefix match on the segment, never `includes('test')`: a live id can
+ * contain the letters `test` anywhere in its random tail, and a substring
+ * check would read a real sale as a rehearsal — the direction that erases
+ * revenue.
+ */
+export declare function stripeIdIsTestMode(id: unknown): boolean;

package/src/lib/app-utils/stripe-deployment-mode.js

@@ -0,0 +1,70 @@
+/**
+ * @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.
+ */ /**
+ * Which Stripe world THIS deployment lives in (AGL-2040, shared in AGL-2486).
+ *
+ * Lifted out of `apps/console/utils/server/stripe-livemode.ts` verbatim so a
+ * LIBRARY can ask the question too — `org-billing.ts` now keys the stored
+ * Stripe customer id by mode, and a lib cannot import from an app. That file
+ * re-exports this one, so the webhook's livemode gate and its spec are
+ * untouched and there is still exactly ONE definition of "are we live".
+ *
+ * Duplicating the `sk_live_` inference instead would have put a second answer
+ * to a money-path question in the tree, and the two would drift the first time
+ * the override was extended.
+ */ /** Explicit ops override, for the case where key-prefix inference is wrong. */ const LIVEMODE_OVERRIDE = 'STRIPE_LIVEMODE';
+/**
+ * Whether THIS deployment is the live one.
+ *
+ * Derived from `STRIPE_SECRET_KEY`'s prefix, with an explicit
+ * `STRIPE_LIVEMODE=true|false` override that wins when set. Note the
+ * asymmetry, which is deliberate: only `sk_live_` yields `true`. An unset or
+ * unrecognised key is NOT a live deployment, because a deployment with no
+ * Stripe secret key cannot be charging anyone.
+ */ export function deploymentLivemode(env = process.env) {
+    var _env_STRIPE_SECRET_KEY;
+    const override = env[LIVEMODE_OVERRIDE];
+    if (override === 'true') return true;
+    if (override === 'false') return false;
+    return String((_env_STRIPE_SECRET_KEY = env['STRIPE_SECRET_KEY']) != null ? _env_STRIPE_SECRET_KEY : '').startsWith('sk_live_');
+}
+/**
+ * Whether a Stripe object id belongs to TEST mode.
+ *
+ * Stripe stamps the environment into the id itself — `cs_test_…`, `pi_test_…`,
+ * `in_test_…` — and that is the only signal a stored document carries when
+ * nothing recorded `livemode` beside it.
+ *
+ * ONE NAMED PLACE, and that is the point of the function rather than a
+ * `.startsWith()` at each call site. This is STRIPE'S convention, not our
+ * data: it is a fact about a third party's id format that we happen to depend
+ * on, so it needs somewhere to be documented, somewhere to be changed, and
+ * somewhere a reader can find every consumer of it. A recorded `livemode`
+ * beats it and callers should prefer one; this is the fallback for documents
+ * written before anything recorded the fact.
+ *
+ * Strict prefix match on the segment, never `includes('test')`: a live id can
+ * contain the letters `test` anywhere in its random tail, and a substring
+ * check would read a real sale as a rehearsal — the direction that erases
+ * revenue.
+ */ export function stripeIdIsTestMode(id) {
+    const value = typeof id === 'string' ? id.trim() : '';
+    if (!value) return false;
+    // `cs_test_…`, and also the `_test_` infix Stripe uses on some prefixed ids.
+    return /^[a-z]+_test_/.test(value);
+}
+
+//# sourceMappingURL=stripe-deployment-mode.js.map

package/src/lib/app-utils/stripe-deployment-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/stripe-deployment-mode.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 * Which Stripe world THIS deployment lives in (AGL-2040, shared in AGL-2486).\n *\n * Lifted out of `apps/console/utils/server/stripe-livemode.ts` verbatim so a\n * LIBRARY can ask the question too — `org-billing.ts` now keys the stored\n * Stripe customer id by mode, and a lib cannot import from an app. That file\n * re-exports this one, so the webhook's livemode gate and its spec are\n * untouched and there is still exactly ONE definition of \"are we live\".\n *\n * Duplicating the `sk_live_` inference instead would have put a second answer\n * to a money-path question in the tree, and the two would drift the first time\n * the override was extended.\n */\n\n/** Explicit ops override, for the case where key-prefix inference is wrong. */\nconst LIVEMODE_OVERRIDE = 'STRIPE_LIVEMODE'\n\n/**\n * Whether THIS deployment is the live one.\n *\n * Derived from `STRIPE_SECRET_KEY`'s prefix, with an explicit\n * `STRIPE_LIVEMODE=true|false` override that wins when set. Note the\n * asymmetry, which is deliberate: only `sk_live_` yields `true`. An unset or\n * unrecognised key is NOT a live deployment, because a deployment with no\n * Stripe secret key cannot be charging anyone.\n */\nexport function deploymentLivemode(\n  env: Partial<Record<string, string>> = process.env,\n): boolean {\n  const override = env[LIVEMODE_OVERRIDE]\n  if (override === 'true') return true\n  if (override === 'false') return false\n  return String(env['STRIPE_SECRET_KEY'] ?? '').startsWith('sk_live_')\n}\n\n/**\n * Whether a Stripe object id belongs to TEST mode.\n *\n * Stripe stamps the environment into the id itself — `cs_test_…`, `pi_test_…`,\n * `in_test_…` — and that is the only signal a stored document carries when\n * nothing recorded `livemode` beside it.\n *\n * ONE NAMED PLACE, and that is the point of the function rather than a\n * `.startsWith()` at each call site. This is STRIPE'S convention, not our\n * data: it is a fact about a third party's id format that we happen to depend\n * on, so it needs somewhere to be documented, somewhere to be changed, and\n * somewhere a reader can find every consumer of it. A recorded `livemode`\n * beats it and callers should prefer one; this is the fallback for documents\n * written before anything recorded the fact.\n *\n * Strict prefix match on the segment, never `includes('test')`: a live id can\n * contain the letters `test` anywhere in its random tail, and a substring\n * check would read a real sale as a rehearsal — the direction that erases\n * revenue.\n */\nexport function stripeIdIsTestMode(id: unknown): boolean {\n  const value = typeof id === 'string' ? id.trim() : ''\n  if (!value) return false\n  // `cs_test_…`, and also the `_test_` infix Stripe uses on some prefixed ids.\n  return /^[a-z]+_test_/.test(value)\n}\n"],"names":["LIVEMODE_OVERRIDE","deploymentLivemode","env","process","override","String","startsWith","stripeIdIsTestMode","id","value","trim","test"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;CAYC,GAED,6EAA6E,GAC7E,MAAMA,oBAAoB;AAE1B;;;;;;;;CAQC,GACD,OAAO,SAASC,mBACdC,MAAuCC,QAAQD,GAAG;QAKpCA;IAHd,MAAME,WAAWF,GAAG,CAACF,kBAAkB;IACvC,IAAII,aAAa,QAAQ,OAAO;IAChC,IAAIA,aAAa,SAAS,OAAO;IACjC,OAAOC,QAAOH,yBAAAA,GAAG,CAAC,oBAAoB,YAAxBA,yBAA4B,IAAII,UAAU,CAAC;AAC3D;AAEA;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASC,mBAAmBC,EAAW;IAC5C,MAAMC,QAAQ,OAAOD,OAAO,WAAWA,GAAGE,IAAI,KAAK;IACnD,IAAI,CAACD,OAAO,OAAO;IACnB,6EAA6E;IAC7E,OAAO,gBAAgBE,IAAI,CAACF;AAC9B"}