@aglyn/aglyn 1.0.0-beta.143

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

@@ -0,0 +1,462 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @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 { stableStringify } from "./marketplace-provenance.js";
+/**
+ * The override layer (AGL-1019) — own the patch, never the copy.
+ *
+ * Customising a marketplace artifact and updating it are only compatible if
+ * they are two different documents. Today they are one: you change a theme's
+ * primary colour and that edits the theme, so the publisher's v2 can be taken
+ * only by discarding your colour, or refused only by missing their fix.
+ *
+ * Here the publisher's version stays untouched as the **base** — AGL-1015
+ * already stores it, content-addressed and immutable, in
+ * `marketplaceArtifactBases/{sha256}` — the user's changes are a **sparse
+ * patch** stored beside it, and readers resolve `base ⊕ patch`. Then:
+ *
+ * * updating replaces the base wholesale and the patch still applies;
+ * * "what did I change" IS the patch, with no diffing at read time;
+ * * "reset to the publisher's version" is deleting the patch;
+ * * a conflict is narrow: only where the patch touches a path the update also
+ *   changed, which the marketplace plugin's three-way update plan already names.
+ *
+ * Pure and content-shaped, exactly like the merge module it sits next to: it
+ * knows nothing about Firestore or artifact types, so one resolver serves a
+ * theme, a node tree and a plugin settings map, and every rule below is
+ * testable without a database.
+ *
+ * ## Which "base" a reader resolves against
+ *
+ * The installed document's OWN content fields — whatever the install route
+ * wrote — are the base at read time, and {@link resolveArtifactContent} takes
+ * them directly. `marketplaceArtifactBases` is not that: it is closed to
+ * clients in both directions (a base can hold paid content, and its key is on
+ * the installed document, so a readable collection would hand out any listing's
+ * content by hash). It is the immutable snapshot the server diffs and resets
+ * against, nothing more.
+ *
+ * The two agree because an update writes the publisher's new version onto the
+ * document and stamps a base at that same hash in one operation — which is the
+ * property that makes "never mutate the vendored artifact" enforceable rather
+ * than merely intended. The moment a user edit lands in those content fields
+ * instead of in the override, both the diff and this resolver are wrong.
+ *
+ * ## Two rules that are load-bearing
+ *
+ * **Deletion needs a sentinel, and it is not `null`.** A sparse patch says
+ * nothing about paths it omits, so "omit it to remove it" is unavailable —
+ * omission already means "inherit". `null` cannot serve either: it is a real
+ * value in this codebase's content, and the besigner's `null`-means-cleared
+ * convention is what took every `/product/*` page down in AGL-1226. So removal
+ * is spelled with {@link OVERRIDE_DELETE}, a value nothing else produces.
+ *
+ * **Arrays are never merged by index.** An insert at position 0 shifts every
+ * element after it, so index-wise merging reports — and then writes — a change
+ * to every one of them. Arrays therefore replace wholesale by default, which is
+ * also how {@link planArtifactUpdate} compares them. Where elements carry a
+ * stable identity the patch may instead use the keyed form
+ * ({@link keyedArrayPatch}) and edit one element by key, so a publisher who
+ * inserts an element does not collide with a user who edited a different one.
+ */ /**
+ * The removal sentinel: a patch value of exactly this string removes the path
+ * from the resolved output.
+ *
+ * A string rather than a wrapper object because a patch travels through
+ * Firestore, JSON responses and React state unchanged, and a scalar survives
+ * all three without anyone needing to know it is special. The cost is that an
+ * artifact whose real content is this exact string cannot be expressed; that is
+ * a deliberate trade for a sentinel that cannot be produced by accident, and
+ * {@link diffOverride} is the only thing that emits it.
+ *
+ * Note this is a field *value*, never a field *name* — Firestore rejects field
+ * names matching `__.*__`, and this deliberately has no trailing underscores so
+ * that a careless refactor into a key still fails loudly rather than silently.
+ */ export const OVERRIDE_DELETE = '__aglynOverrideDelete';
+/**
+ * The field on an installed artifact document that holds its override.
+ *
+ * Beside the base, never inside it. The document's content fields keep holding
+ * the publisher's version verbatim, which is what makes an update a wholesale
+ * replacement of those fields and nothing else. Writing the user's edits into
+ * the content instead is precisely the state this issue exists to leave.
+ */ export const ARTIFACT_OVERRIDE_FIELD = 'overrides';
+/** Identity fields tried, in order, when deciding whether an array is keyed. */ const KEY_FIELDS = [
+    'id',
+    'key',
+    'slug',
+    'name'
+];
+const isPlainObject = (value)=>value != null && typeof value === 'object' && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const same = (a, b)=>stableStringify(a) === stableStringify(b);
+export const isDeleteSentinel = (value)=>value === OVERRIDE_DELETE;
+export function isKeyedArrayPatch(value) {
+    return isPlainObject(value) && typeof value['keyedBy'] === 'string' && isPlainObject(value['entries']);
+}
+/**
+ * The identity field this array is keyed by, or null when it is not keyed.
+ *
+ * Every element must be a plain object carrying the same field, and every value
+ * must be a non-empty string that appears once. A single duplicate or missing
+ * key makes the whole array unkeyed rather than partly keyed — a patch that can
+ * address only some elements is worse than one that addresses none, because the
+ * gaps are invisible at the call site.
+ */ export function arrayKeyField(value) {
+    if (!Array.isArray(value) || !value.length) return null;
+    if (!value.every(isPlainObject)) return null;
+    for (const field of KEY_FIELDS){
+        const keys = value.map((entry)=>entry[field]);
+        if (!keys.every((key)=>typeof key === 'string' && key !== '')) continue;
+        if (new Set(keys).size !== keys.length) continue;
+        return field;
+    }
+    return null;
+}
+/** Builds a keyed-array patch, dropping it entirely when it says nothing. */ function keyedArrayPatch(keyedBy, entries, order) {
+    if (!Object.keys(entries).length && !order) return undefined;
+    return _extends({
+        keyedBy,
+        entries
+    }, order ? {
+        order
+    } : {});
+}
+/**
+ * `base ⊕ patch` — the resolved view every reader sees.
+ *
+ * Deep-merges plain objects; everything else the patch names replaces what the
+ * base holds. The base is never mutated: each level is copied on write, so a
+ * caller can resolve the same base against two patches and get two answers.
+ *
+ * A patch that names a path the base does not have simply adds it. That is what
+ * makes the same function serve "override a publisher's field" and "set a field
+ * the publisher never shipped", and it is why a resolved artifact can be richer
+ * than its base rather than only a recolouring of it.
+ */ export function resolveOverride(base, patch) {
+    return resolve(base, patch);
+}
+function resolve(base, patch) {
+    if (patch === undefined) return base;
+    if (isDeleteSentinel(patch)) return undefined;
+    if (isKeyedArrayPatch(patch)) return resolveKeyedArray(base, patch);
+    if (isPlainObject(patch) && isPlainObject(base)) {
+        const merged = _extends({}, base);
+        for (const [key, value] of Object.entries(patch)){
+            const resolved = resolve(merged[key], value);
+            if (resolved === undefined) delete merged[key];
+            else merged[key] = resolved;
+        }
+        return merged;
+    }
+    // A patch object over a non-object base still applies — the patch wins, and
+    // its own delete sentinels are honoured so that `{a: DELETE}` over `null`
+    // resolves to `{}` rather than smuggling the sentinel into the output.
+    if (isPlainObject(patch)) return resolve({}, patch);
+    return patch;
+}
+function resolveKeyedArray(base, patch) {
+    const source = Array.isArray(base) ? base : [];
+    const keyOf = (entry)=>{
+        const key = isPlainObject(entry) ? entry[patch.keyedBy] : undefined;
+        return typeof key === 'string' && key !== '' ? key : undefined;
+    };
+    const resolved = [];
+    for (const entry of source){
+        const key = keyOf(entry);
+        // An unkeyed element in an otherwise keyed array is unaddressable, so it is
+        // carried through untouched rather than dropped: the patch never claimed to
+        // describe it.
+        if (key === undefined || !(key in patch.entries)) {
+            resolved.push({
+                key,
+                value: entry
+            });
+            continue;
+        }
+        const value = resolve(entry, patch.entries[key]);
+        if (value !== undefined) resolved.push({
+            key,
+            value
+        });
+    }
+    // Entries the base does not hold are additions, appended in patch order.
+    const present = new Set(resolved.map((entry)=>entry.key));
+    for (const [key, value] of Object.entries(patch.entries)){
+        if (present.has(key) || isDeleteSentinel(value)) continue;
+        const added = resolve(undefined, value);
+        if (added !== undefined) resolved.push({
+            key,
+            value: added
+        });
+    }
+    if (!patch.order) return resolved.map((entry)=>entry.value);
+    // Ordered: the listed keys first, in the order given, then everything the
+    // order did not mention in its existing relative position. A key in `order`
+    // that no longer exists is skipped rather than inserted as a hole.
+    const rank = new Map(patch.order.map((key, index)=>[
+            key,
+            index
+        ]));
+    return resolved.map((entry, index)=>_extends({}, entry, {
+            rank: entry.key != null && rank.has(entry.key) ? rank.get(entry.key) : patch.order.length + index
+        })).sort((a, b)=>a.rank - b.rank).map((entry)=>entry.value);
+}
+/**
+ * "What did I change" — the sparse patch that turns `base` into `edited`.
+ *
+ * The inverse of {@link resolveOverride}, and held to it:
+ * `resolveOverride(base, diffOverride(base, edited))` equals `edited` for every
+ * shape this codebase stores. That round trip is the module's central property
+ * and the thing its tests exist to defend, because every consumer downstream —
+ * themes, theme overrides, host variables, plugin settings — inherits it.
+ *
+ * Returns `undefined` when nothing changed, so an unedited artifact stores no
+ * override at all rather than an empty husk that reads as "customised".
+ */ export function diffOverride(base, edited) {
+    if (same(base, edited)) return undefined;
+    if (edited === undefined) return OVERRIDE_DELETE;
+    if (isPlainObject(base) && isPlainObject(edited)) {
+        const patch = {};
+        for (const [key, value] of Object.entries(edited)){
+            const child = diffOverride(base[key], value);
+            if (child !== undefined) patch[key] = child;
+        }
+        for (const key of Object.keys(base)){
+            if (!(key in edited)) patch[key] = OVERRIDE_DELETE;
+        }
+        return patch;
+    }
+    if (Array.isArray(base) && Array.isArray(edited)) {
+        const keyed = diffKeyedArray(base, edited);
+        if (keyed) return keyed;
+    }
+    return edited;
+}
+/**
+ * A per-element patch for two keyed arrays, or null when they are not both
+ * keyed by the same field — in which case the caller falls back to replacing
+ * the array wholesale, which is always correct if sometimes coarse.
+ */ function diffKeyedArray(base, edited) {
+    const field = arrayKeyField(base);
+    if (!field || arrayKeyField(edited) !== field) return null;
+    const keyOf = (entry)=>String(entry[field]);
+    const baseByKey = new Map(base.map((entry)=>[
+            keyOf(entry),
+            entry
+        ]));
+    const editedKeys = edited.map(keyOf);
+    const entries = {};
+    for (const entry of edited){
+        const key = keyOf(entry);
+        const child = diffOverride(baseByKey.get(key), entry);
+        if (child !== undefined) entries[key] = child;
+    }
+    for (const key of baseByKey.keys()){
+        if (!editedKeys.includes(key)) entries[key] = OVERRIDE_DELETE;
+    }
+    // Order is stored only when the resolver would not already produce it —
+    // surviving elements in the base's order, then additions in the order they
+    // appear. So the common case (a value edit, or an element appended) stores no
+    // order and leaves the publisher free to insert elements of their own, while
+    // a genuine reorder or a mid-list insert is pinned.
+    const natural = [
+        ...base.map(keyOf).filter((key)=>editedKeys.includes(key)),
+        ...editedKeys.filter((key)=>!baseByKey.has(key))
+    ];
+    const reordered = !same(natural, editedKeys);
+    return keyedArrayPatch(field, entries, reordered ? editedKeys : undefined);
+}
+/**
+ * Every path the patch touches, dotted, for "what did I change" in a UI and for
+ * pairing an override against an update plan's conflicts — whose paths
+ * {@link planArtifactUpdate} spells the same way.
+ *
+ * A keyed array contributes `field[key]` segments rather than indices, because
+ * an index is exactly the thing that stops meaning the same element the moment
+ * the publisher inserts one.
+ */ export function overridePaths(patch, prefix = '') {
+    if (patch === undefined) return [];
+    if (isKeyedArrayPatch(patch)) {
+        return Object.entries(patch.entries).flatMap(([key, value])=>overridePaths(value, `${prefix}[${key}]`));
+    }
+    if (isPlainObject(patch) && !isDeleteSentinel(patch)) {
+        const keys = Object.keys(patch);
+        if (keys.length) {
+            return keys.flatMap((key)=>overridePaths(patch[key], prefix ? `${prefix}.${key}` : key));
+        }
+    }
+    return prefix ? [
+        prefix
+    ] : [];
+}
+/**
+ * True when the patch says nothing — the artifact is the publisher's, as shipped.
+ *
+ * `undefined` is the only absence. A `null` is a VALUE the user chose, and
+ * calling it empty here would silently discard "set this field to null" on
+ * every save — the same conflation between "cleared" and "absent" that took
+ * every `/product/*` page down in AGL-1226.
+ */ export function isEmptyOverride(patch) {
+    if (patch === undefined) return true;
+    if (isKeyedArrayPatch(patch)) {
+        return !patch.order && Object.values(patch.entries).every(isEmptyOverride);
+    }
+    if (isDeleteSentinel(patch)) return false;
+    if (isPlainObject(patch)) return Object.values(patch).every(isEmptyOverride);
+    return false;
+}
+/**
+ * Is this shape storable as a whole-artifact override?
+ *
+ * A patch is a *sparse* description of edits to a structured artifact, so its
+ * top level is an object or a keyed array and nothing else. A stored scalar —
+ * above all a top-level `null` — would resolve the entire artifact away, which
+ * is never something a user did on purpose and always something a half-written
+ * or hand-edited field can produce. Nested nulls stay values; only the root is
+ * constrained, and constraining it is what keeps a junk field from blanking a
+ * live site.
+ */ function isStorablePatch(patch) {
+    return (isKeyedArrayPatch(patch) || isPlainObject(patch)) && !isEmptyOverride(patch);
+}
+/**
+ * Can this artifact hold an override at all? (AGL-1015's provenance, answered.)
+ *
+ * An override is a patch over the publisher's version, so an artifact with no
+ * recorded base has nothing to be a patch *of*. Storing one anyway would
+ * produce a patch against whatever the document happened to hold — including
+ * the user's own earlier edits — and the first update would resolve it against
+ * a base it was never written for. Saying so plainly is the whole point of the
+ * `updatable` flag; this is the sentence to put next to the disabled control.
+ */ export function canOverrideArtifact(provenance) {
+    if (!provenance || provenance.state === 'unknown') {
+        return {
+            ok: false,
+            reason: 'This was not installed from the marketplace, so there is no ' + 'publisher’s version to keep your changes separate from. Edit it ' + 'directly — it is already yours.'
+        };
+    }
+    if (!provenance.updatable) {
+        return {
+            ok: false,
+            reason: 'This was installed before update tracking recorded an original, so ' + 'there is nothing to layer your changes over. Re-installing it from ' + 'the listing records one, and your changes can be kept separately ' + 'from then on.'
+        };
+    }
+    return {
+        ok: true
+    };
+}
+/**
+ * The value to write under {@link ARTIFACT_OVERRIDE_FIELD} — or `null`, meaning
+ * "reset to the publisher's version", when the patch says nothing.
+ *
+ * ## Write this WHOLESALE. Never with `merge: true`.
+ *
+ * Firestore's `merge: true` deep-merges maps, and a patch is a map, so merging
+ * a new patch onto an old one takes their union: every path the user has ever
+ * overridden stays overridden, and removing an override becomes impossible
+ * through the one write that looks like it should do it. `merge: true` on the
+ * *document* is fine and expected — it is this *field* that must be replaced,
+ * which is what passing this value under a `FieldPath` to `update`, or under
+ * `set(..., {mergeFields})`, does:
+ *
+ * ```ts
+ * await ref.set(
+ *   { [ARTIFACT_OVERRIDE_FIELD]: overrideWriteValue(patch, sha256), updatedAt },
+ *   { mergeFields: [ARTIFACT_OVERRIDE_FIELD, 'updatedAt'] },
+ * )
+ * ```
+ *
+ * The `null` for an empty patch is deliberate over a field delete: a reader
+ * that sees `null` knows the override was considered and is empty, which reads
+ * the same as absent and needs no second code path.
+ */ export function overrideWriteValue(patch, baseSha256, meta) {
+    if (!isStorablePatch(patch)) return null;
+    return _extends({
+        patch,
+        baseSha256
+    }, (meta == null ? void 0 : meta.updatedAt) !== undefined ? {
+        updatedAt: meta.updatedAt
+    } : {}, (meta == null ? void 0 : meta.updatedBy) !== undefined ? {
+        updatedBy: meta.updatedBy
+    } : {});
+}
+/**
+ * Reads a stored override off a document, tolerating the junk a client-writable
+ * field can hold.
+ *
+ * Returns `undefined` for anything that is not a well-formed override, so a
+ * corrupt field resolves to the publisher's version rather than throwing on a
+ * page that would otherwise render.
+ */ export function readArtifactOverride(doc) {
+    const stored = doc == null ? void 0 : doc[ARTIFACT_OVERRIDE_FIELD];
+    if (!isPlainObject(stored)) return undefined;
+    if (!isStorablePatch(stored['patch'])) return undefined;
+    const sha = stored['baseSha256'];
+    return _extends({
+        patch: stored['patch'],
+        baseSha256: typeof sha === 'string' && sha ? sha : null
+    }, stored['updatedAt'] !== undefined ? {
+        updatedAt: stored['updatedAt']
+    } : {}, typeof stored['updatedBy'] === 'string' ? {
+        updatedBy: stored['updatedBy']
+    } : {});
+}
+/**
+ * The one call a reader makes: the publisher's content with this document's
+ * override resolved over it.
+ *
+ * `content` is the artifact's own fields — whatever shape the install route
+ * wrote, unchanged — so a caller never has to know whether an override exists.
+ */ export function resolveArtifactContent(content, doc) {
+    const override = readArtifactOverride(doc);
+    return override ? resolveOverride(content, override.patch) : content;
+}
+/**
+ * The paths where an incoming update collides with what the user overrode.
+ *
+ * Narrow by construction, which is the payoff the whole layer was built for: a
+ * patch touching four paths can conflict in at most four places no matter how
+ * much of the artifact the publisher rewrote, so the question put to the user is
+ * "the publisher also changed your heading colour — whose wins?" rather than
+ * "this update rewrites 300 nodes, continue?".
+ *
+ * A path whose incoming value already equals what the override sets is not a
+ * conflict — the publisher adopted the user's change, and there is nothing to
+ * ask about.
+ */ export function overrideConflicts(base, patch, incoming) {
+    const overridden = resolveOverride(base, patch);
+    return overridePaths(patch).filter((path)=>{
+        const baseValue = readPath(base, path);
+        const incomingValue = readPath(incoming, path);
+        if (same(baseValue, incomingValue)) return false;
+        return !same(readPath(overridden, path), incomingValue);
+    });
+}
+/** Reads a dotted path, understanding the `field[key]` segments keyed arrays use. */ function readPath(value, path) {
+    var _path_match;
+    let cursor = value;
+    for (const segment of (_path_match = path.match(/[^.[\]]+/g)) != null ? _path_match : []){
+        if (Array.isArray(cursor)) {
+            const field = arrayKeyField(cursor);
+            cursor = field ? cursor.find((entry)=>entry[field] === segment) : undefined;
+            continue;
+        }
+        if (!isPlainObject(cursor)) return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+
+//# sourceMappingURL=marketplace-overrides.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/marketplace-overrides.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 {\n  stableStringify,\n  type ResolvedProvenance,\n} from './marketplace-provenance'\n\n/**\n * The override layer (AGL-1019) — own the patch, never the copy.\n *\n * Customising a marketplace artifact and updating it are only compatible if\n * they are two different documents. Today they are one: you change a theme's\n * primary colour and that edits the theme, so the publisher's v2 can be taken\n * only by discarding your colour, or refused only by missing their fix.\n *\n * Here the publisher's version stays untouched as the **base** — AGL-1015\n * already stores it, content-addressed and immutable, in\n * `marketplaceArtifactBases/{sha256}` — the user's changes are a **sparse\n * patch** stored beside it, and readers resolve `base ⊕ patch`. Then:\n *\n * * updating replaces the base wholesale and the patch still applies;\n * * \"what did I change\" IS the patch, with no diffing at read time;\n * * \"reset to the publisher's version\" is deleting the patch;\n * * a conflict is narrow: only where the patch touches a path the update also\n *   changed, which the marketplace plugin's three-way update plan already names.\n *\n * Pure and content-shaped, exactly like the merge module it sits next to: it\n * knows nothing about Firestore or artifact types, so one resolver serves a\n * theme, a node tree and a plugin settings map, and every rule below is\n * testable without a database.\n *\n * ## Which \"base\" a reader resolves against\n *\n * The installed document's OWN content fields — whatever the install route\n * wrote — are the base at read time, and {@link resolveArtifactContent} takes\n * them directly. `marketplaceArtifactBases` is not that: it is closed to\n * clients in both directions (a base can hold paid content, and its key is on\n * the installed document, so a readable collection would hand out any listing's\n * content by hash). It is the immutable snapshot the server diffs and resets\n * against, nothing more.\n *\n * The two agree because an update writes the publisher's new version onto the\n * document and stamps a base at that same hash in one operation — which is the\n * property that makes \"never mutate the vendored artifact\" enforceable rather\n * than merely intended. The moment a user edit lands in those content fields\n * instead of in the override, both the diff and this resolver are wrong.\n *\n * ## Two rules that are load-bearing\n *\n * **Deletion needs a sentinel, and it is not `null`.** A sparse patch says\n * nothing about paths it omits, so \"omit it to remove it\" is unavailable —\n * omission already means \"inherit\". `null` cannot serve either: it is a real\n * value in this codebase's content, and the besigner's `null`-means-cleared\n * convention is what took every `/product/*` page down in AGL-1226. So removal\n * is spelled with {@link OVERRIDE_DELETE}, a value nothing else produces.\n *\n * **Arrays are never merged by index.** An insert at position 0 shifts every\n * element after it, so index-wise merging reports — and then writes — a change\n * to every one of them. Arrays therefore replace wholesale by default, which is\n * also how {@link planArtifactUpdate} compares them. Where elements carry a\n * stable identity the patch may instead use the keyed form\n * ({@link keyedArrayPatch}) and edit one element by key, so a publisher who\n * inserts an element does not collide with a user who edited a different one.\n */\n\n/**\n * The removal sentinel: a patch value of exactly this string removes the path\n * from the resolved output.\n *\n * A string rather than a wrapper object because a patch travels through\n * Firestore, JSON responses and React state unchanged, and a scalar survives\n * all three without anyone needing to know it is special. The cost is that an\n * artifact whose real content is this exact string cannot be expressed; that is\n * a deliberate trade for a sentinel that cannot be produced by accident, and\n * {@link diffOverride} is the only thing that emits it.\n *\n * Note this is a field *value*, never a field *name* — Firestore rejects field\n * names matching `__.*__`, and this deliberately has no trailing underscores so\n * that a careless refactor into a key still fails loudly rather than silently.\n */\nexport const OVERRIDE_DELETE = '__aglynOverrideDelete'\n\n/**\n * The field on an installed artifact document that holds its override.\n *\n * Beside the base, never inside it. The document's content fields keep holding\n * the publisher's version verbatim, which is what makes an update a wholesale\n * replacement of those fields and nothing else. Writing the user's edits into\n * the content instead is precisely the state this issue exists to leave.\n */\nexport const ARTIFACT_OVERRIDE_FIELD = 'overrides'\n\n/** The stored override, as written under {@link ARTIFACT_OVERRIDE_FIELD}. */\nexport interface ArtifactOverride {\n  /** The sparse patch. Resolved over the artifact's content at read time. */\n  patch: unknown\n  /**\n   * The base the patch was authored against — `installedFrom.sha256`.\n   *\n   * Recorded, not enforced: a patch stays valid across an update by design, and\n   * the only thing this answers is \"which publisher version was on screen when\n   * these edits were made\", which is what a conflict report needs to be honest.\n   */\n  baseSha256: string | null\n  updatedAt?: unknown\n  updatedBy?: string | null\n}\n\n/**\n * A patch node that edits an array BY KEY instead of replacing it.\n *\n * Only ever produced for arrays whose elements are objects carrying a unique\n * value under one identity field, because that is the only case where \"the\n * third element\" and \"the element the publisher shipped third\" are different\n * questions with the same answer.\n */\nexport interface KeyedArrayPatch {\n  /** Discriminator. Present only on this form. */\n  keyedBy: string\n  /** Per-key sub-patches; a value of {@link OVERRIDE_DELETE} removes the element. */\n  entries: Record<string, unknown>\n  /**\n   * The full key order, when the user reordered the array.\n   *\n   * Absent when they did not — and absence is the point: an array with no\n   * `order` lets a publisher insert an element and have it appear, while an\n   * array with one pins the order the user chose. Keys present in the base but\n   * missing from `order` keep their relative position at the end, so a stale\n   * `order` never drops an element.\n   */\n  order?: string[]\n}\n\n/** Identity fields tried, in order, when deciding whether an array is keyed. */\nconst KEY_FIELDS = ['id', 'key', 'slug', 'name'] as const\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  value != null &&\n  typeof value === 'object' &&\n  !Array.isArray(value) &&\n  (Object.getPrototypeOf(value) === Object.prototype ||\n    Object.getPrototypeOf(value) === null)\n\nconst same = (a: unknown, b: unknown): boolean =>\n  stableStringify(a) === stableStringify(b)\n\nexport const isDeleteSentinel = (value: unknown): boolean =>\n  value === OVERRIDE_DELETE\n\nexport function isKeyedArrayPatch(value: unknown): value is KeyedArrayPatch {\n  return (\n    isPlainObject(value) &&\n    typeof value['keyedBy'] === 'string' &&\n    isPlainObject(value['entries'])\n  )\n}\n\n/**\n * The identity field this array is keyed by, or null when it is not keyed.\n *\n * Every element must be a plain object carrying the same field, and every value\n * must be a non-empty string that appears once. A single duplicate or missing\n * key makes the whole array unkeyed rather than partly keyed — a patch that can\n * address only some elements is worse than one that addresses none, because the\n * gaps are invisible at the call site.\n */\nexport function arrayKeyField(value: unknown): string | null {\n  if (!Array.isArray(value) || !value.length) return null\n  if (!value.every(isPlainObject)) return null\n  for (const field of KEY_FIELDS) {\n    const keys = value.map((entry) => (entry as Record<string, unknown>)[field])\n    if (!keys.every((key) => typeof key === 'string' && key !== '')) continue\n    if (new Set(keys as string[]).size !== keys.length) continue\n    return field\n  }\n  return null\n}\n\n/** Builds a keyed-array patch, dropping it entirely when it says nothing. */\nfunction keyedArrayPatch(\n  keyedBy: string,\n  entries: Record<string, unknown>,\n  order: string[] | undefined,\n): KeyedArrayPatch | undefined {\n  if (!Object.keys(entries).length && !order) return undefined\n  return { keyedBy, entries, ...(order ? { order } : {}) }\n}\n\n/**\n * `base ⊕ patch` — the resolved view every reader sees.\n *\n * Deep-merges plain objects; everything else the patch names replaces what the\n * base holds. The base is never mutated: each level is copied on write, so a\n * caller can resolve the same base against two patches and get two answers.\n *\n * A patch that names a path the base does not have simply adds it. That is what\n * makes the same function serve \"override a publisher's field\" and \"set a field\n * the publisher never shipped\", and it is why a resolved artifact can be richer\n * than its base rather than only a recolouring of it.\n */\nexport function resolveOverride<T = unknown>(base: unknown, patch: unknown): T {\n  return resolve(base, patch) as T\n}\n\nfunction resolve(base: unknown, patch: unknown): unknown {\n  if (patch === undefined) return base\n  if (isDeleteSentinel(patch)) return undefined\n\n  if (isKeyedArrayPatch(patch)) return resolveKeyedArray(base, patch)\n\n  if (isPlainObject(patch) && isPlainObject(base)) {\n    const merged: Record<string, unknown> = { ...base }\n    for (const [key, value] of Object.entries(patch)) {\n      const resolved = resolve(merged[key], value)\n      if (resolved === undefined) delete merged[key]\n      else merged[key] = resolved\n    }\n    return merged\n  }\n\n  // A patch object over a non-object base still applies — the patch wins, and\n  // its own delete sentinels are honoured so that `{a: DELETE}` over `null`\n  // resolves to `{}` rather than smuggling the sentinel into the output.\n  if (isPlainObject(patch)) return resolve({}, patch)\n\n  return patch\n}\n\nfunction resolveKeyedArray(base: unknown, patch: KeyedArrayPatch): unknown[] {\n  const source = Array.isArray(base) ? base : []\n  const keyOf = (entry: unknown): string | undefined => {\n    const key = isPlainObject(entry) ? entry[patch.keyedBy] : undefined\n    return typeof key === 'string' && key !== '' ? key : undefined\n  }\n\n  const resolved: Array<{ key: string | undefined; value: unknown }> = []\n  for (const entry of source) {\n    const key = keyOf(entry)\n    // An unkeyed element in an otherwise keyed array is unaddressable, so it is\n    // carried through untouched rather than dropped: the patch never claimed to\n    // describe it.\n    if (key === undefined || !(key in patch.entries)) {\n      resolved.push({ key, value: entry })\n      continue\n    }\n    const value = resolve(entry, patch.entries[key])\n    if (value !== undefined) resolved.push({ key, value })\n  }\n\n  // Entries the base does not hold are additions, appended in patch order.\n  const present = new Set(resolved.map((entry) => entry.key))\n  for (const [key, value] of Object.entries(patch.entries)) {\n    if (present.has(key) || isDeleteSentinel(value)) continue\n    const added = resolve(undefined, value)\n    if (added !== undefined) resolved.push({ key, value: added })\n  }\n\n  if (!patch.order) return resolved.map((entry) => entry.value)\n\n  // Ordered: the listed keys first, in the order given, then everything the\n  // order did not mention in its existing relative position. A key in `order`\n  // that no longer exists is skipped rather than inserted as a hole.\n  const rank = new Map(patch.order.map((key, index) => [key, index]))\n  return resolved\n    .map((entry, index) => ({\n      ...entry,\n      rank: entry.key != null && rank.has(entry.key)\n        ? (rank.get(entry.key) as number)\n        : patch.order!.length + index,\n    }))\n    .sort((a, b) => a.rank - b.rank)\n    .map((entry) => entry.value)\n}\n\n/**\n * \"What did I change\" — the sparse patch that turns `base` into `edited`.\n *\n * The inverse of {@link resolveOverride}, and held to it:\n * `resolveOverride(base, diffOverride(base, edited))` equals `edited` for every\n * shape this codebase stores. That round trip is the module's central property\n * and the thing its tests exist to defend, because every consumer downstream —\n * themes, theme overrides, host variables, plugin settings — inherits it.\n *\n * Returns `undefined` when nothing changed, so an unedited artifact stores no\n * override at all rather than an empty husk that reads as \"customised\".\n */\nexport function diffOverride(base: unknown, edited: unknown): unknown {\n  if (same(base, edited)) return undefined\n  if (edited === undefined) return OVERRIDE_DELETE\n\n  if (isPlainObject(base) && isPlainObject(edited)) {\n    const patch: Record<string, unknown> = {}\n    for (const [key, value] of Object.entries(edited)) {\n      const child = diffOverride(base[key], value)\n      if (child !== undefined) patch[key] = child\n    }\n    for (const key of Object.keys(base)) {\n      if (!(key in edited)) patch[key] = OVERRIDE_DELETE\n    }\n    return patch\n  }\n\n  if (Array.isArray(base) && Array.isArray(edited)) {\n    const keyed = diffKeyedArray(base, edited)\n    if (keyed) return keyed\n  }\n\n  return edited\n}\n\n/**\n * A per-element patch for two keyed arrays, or null when they are not both\n * keyed by the same field — in which case the caller falls back to replacing\n * the array wholesale, which is always correct if sometimes coarse.\n */\nfunction diffKeyedArray(\n  base: unknown[],\n  edited: unknown[],\n): KeyedArrayPatch | undefined | null {\n  const field = arrayKeyField(base)\n  if (!field || arrayKeyField(edited) !== field) return null\n\n  const keyOf = (entry: unknown) =>\n    String((entry as Record<string, unknown>)[field])\n  const baseByKey = new Map(base.map((entry) => [keyOf(entry), entry]))\n  const editedKeys = edited.map(keyOf)\n\n  const entries: Record<string, unknown> = {}\n  for (const entry of edited) {\n    const key = keyOf(entry)\n    const child = diffOverride(baseByKey.get(key), entry)\n    if (child !== undefined) entries[key] = child\n  }\n  for (const key of baseByKey.keys()) {\n    if (!editedKeys.includes(key)) entries[key] = OVERRIDE_DELETE\n  }\n\n  // Order is stored only when the resolver would not already produce it —\n  // surviving elements in the base's order, then additions in the order they\n  // appear. So the common case (a value edit, or an element appended) stores no\n  // order and leaves the publisher free to insert elements of their own, while\n  // a genuine reorder or a mid-list insert is pinned.\n  const natural = [\n    ...base.map(keyOf).filter((key) => editedKeys.includes(key)),\n    ...editedKeys.filter((key) => !baseByKey.has(key)),\n  ]\n  const reordered = !same(natural, editedKeys)\n\n  return keyedArrayPatch(field, entries, reordered ? editedKeys : undefined)\n}\n\n/**\n * Every path the patch touches, dotted, for \"what did I change\" in a UI and for\n * pairing an override against an update plan's conflicts — whose paths\n * {@link planArtifactUpdate} spells the same way.\n *\n * A keyed array contributes `field[key]` segments rather than indices, because\n * an index is exactly the thing that stops meaning the same element the moment\n * the publisher inserts one.\n */\nexport function overridePaths(patch: unknown, prefix = ''): string[] {\n  if (patch === undefined) return []\n  if (isKeyedArrayPatch(patch)) {\n    return Object.entries(patch.entries).flatMap(([key, value]) =>\n      overridePaths(value, `${prefix}[${key}]`),\n    )\n  }\n  if (isPlainObject(patch) && !isDeleteSentinel(patch)) {\n    const keys = Object.keys(patch)\n    if (keys.length) {\n      return keys.flatMap((key) =>\n        overridePaths(patch[key], prefix ? `${prefix}.${key}` : key),\n      )\n    }\n  }\n  return prefix ? [prefix] : []\n}\n\n/**\n * True when the patch says nothing — the artifact is the publisher's, as shipped.\n *\n * `undefined` is the only absence. A `null` is a VALUE the user chose, and\n * calling it empty here would silently discard \"set this field to null\" on\n * every save — the same conflation between \"cleared\" and \"absent\" that took\n * every `/product/*` page down in AGL-1226.\n */\nexport function isEmptyOverride(patch: unknown): boolean {\n  if (patch === undefined) return true\n  if (isKeyedArrayPatch(patch)) {\n    return !patch.order && Object.values(patch.entries).every(isEmptyOverride)\n  }\n  if (isDeleteSentinel(patch)) return false\n  if (isPlainObject(patch)) return Object.values(patch).every(isEmptyOverride)\n  return false\n}\n\n/**\n * Is this shape storable as a whole-artifact override?\n *\n * A patch is a *sparse* description of edits to a structured artifact, so its\n * top level is an object or a keyed array and nothing else. A stored scalar —\n * above all a top-level `null` — would resolve the entire artifact away, which\n * is never something a user did on purpose and always something a half-written\n * or hand-edited field can produce. Nested nulls stay values; only the root is\n * constrained, and constraining it is what keeps a junk field from blanking a\n * live site.\n */\nfunction isStorablePatch(patch: unknown): boolean {\n  return (\n    (isKeyedArrayPatch(patch) || isPlainObject(patch)) && !isEmptyOverride(patch)\n  )\n}\n\nexport interface OverrideEligibility {\n  ok: boolean\n  /** Why not, in the words the surface refusing it should use. */\n  reason?: string\n}\n\n/**\n * Can this artifact hold an override at all? (AGL-1015's provenance, answered.)\n *\n * An override is a patch over the publisher's version, so an artifact with no\n * recorded base has nothing to be a patch *of*. Storing one anyway would\n * produce a patch against whatever the document happened to hold — including\n * the user's own earlier edits — and the first update would resolve it against\n * a base it was never written for. Saying so plainly is the whole point of the\n * `updatable` flag; this is the sentence to put next to the disabled control.\n */\nexport function canOverrideArtifact(\n  provenance: ResolvedProvenance | null | undefined,\n): OverrideEligibility {\n  if (!provenance || provenance.state === 'unknown') {\n    return {\n      ok: false,\n      reason:\n        'This was not installed from the marketplace, so there is no ' +\n        'publisher’s version to keep your changes separate from. Edit it ' +\n        'directly — it is already yours.',\n    }\n  }\n  if (!provenance.updatable) {\n    return {\n      ok: false,\n      reason:\n        'This was installed before update tracking recorded an original, so ' +\n        'there is nothing to layer your changes over. Re-installing it from ' +\n        'the listing records one, and your changes can be kept separately ' +\n        'from then on.',\n    }\n  }\n  return { ok: true }\n}\n\n/**\n * The value to write under {@link ARTIFACT_OVERRIDE_FIELD} — or `null`, meaning\n * \"reset to the publisher's version\", when the patch says nothing.\n *\n * ## Write this WHOLESALE. Never with `merge: true`.\n *\n * Firestore's `merge: true` deep-merges maps, and a patch is a map, so merging\n * a new patch onto an old one takes their union: every path the user has ever\n * overridden stays overridden, and removing an override becomes impossible\n * through the one write that looks like it should do it. `merge: true` on the\n * *document* is fine and expected — it is this *field* that must be replaced,\n * which is what passing this value under a `FieldPath` to `update`, or under\n * `set(..., {mergeFields})`, does:\n *\n * ```ts\n * await ref.set(\n *   { [ARTIFACT_OVERRIDE_FIELD]: overrideWriteValue(patch, sha256), updatedAt },\n *   { mergeFields: [ARTIFACT_OVERRIDE_FIELD, 'updatedAt'] },\n * )\n * ```\n *\n * The `null` for an empty patch is deliberate over a field delete: a reader\n * that sees `null` knows the override was considered and is empty, which reads\n * the same as absent and needs no second code path.\n */\nexport function overrideWriteValue(\n  patch: unknown,\n  baseSha256: string | null,\n  meta?: { updatedAt?: unknown; updatedBy?: string | null },\n): ArtifactOverride | null {\n  if (!isStorablePatch(patch)) return null\n  return {\n    patch,\n    baseSha256,\n    ...(meta?.updatedAt !== undefined ? { updatedAt: meta.updatedAt } : {}),\n    ...(meta?.updatedBy !== undefined ? { updatedBy: meta.updatedBy } : {}),\n  }\n}\n\n/**\n * Reads a stored override off a document, tolerating the junk a client-writable\n * field can hold.\n *\n * Returns `undefined` for anything that is not a well-formed override, so a\n * corrupt field resolves to the publisher's version rather than throwing on a\n * page that would otherwise render.\n */\nexport function readArtifactOverride(\n  doc: Record<string, unknown> | null | undefined,\n): ArtifactOverride | undefined {\n  const stored = doc?.[ARTIFACT_OVERRIDE_FIELD]\n  if (!isPlainObject(stored)) return undefined\n  if (!isStorablePatch(stored['patch'])) return undefined\n  const sha = stored['baseSha256']\n  return {\n    patch: stored['patch'],\n    baseSha256: typeof sha === 'string' && sha ? sha : null,\n    ...(stored['updatedAt'] !== undefined ? { updatedAt: stored['updatedAt'] } : {}),\n    ...(typeof stored['updatedBy'] === 'string'\n      ? { updatedBy: stored['updatedBy'] }\n      : {}),\n  }\n}\n\n/**\n * The one call a reader makes: the publisher's content with this document's\n * override resolved over it.\n *\n * `content` is the artifact's own fields — whatever shape the install route\n * wrote, unchanged — so a caller never has to know whether an override exists.\n */\nexport function resolveArtifactContent<T = unknown>(\n  content: unknown,\n  doc: Record<string, unknown> | null | undefined,\n): T {\n  const override = readArtifactOverride(doc)\n  return (override ? resolveOverride(content, override.patch) : content) as T\n}\n\n/**\n * The paths where an incoming update collides with what the user overrode.\n *\n * Narrow by construction, which is the payoff the whole layer was built for: a\n * patch touching four paths can conflict in at most four places no matter how\n * much of the artifact the publisher rewrote, so the question put to the user is\n * \"the publisher also changed your heading colour — whose wins?\" rather than\n * \"this update rewrites 300 nodes, continue?\".\n *\n * A path whose incoming value already equals what the override sets is not a\n * conflict — the publisher adopted the user's change, and there is nothing to\n * ask about.\n */\nexport function overrideConflicts(\n  base: unknown,\n  patch: unknown,\n  incoming: unknown,\n): string[] {\n  const overridden = resolveOverride(base, patch)\n  return overridePaths(patch).filter((path) => {\n    const baseValue = readPath(base, path)\n    const incomingValue = readPath(incoming, path)\n    if (same(baseValue, incomingValue)) return false\n    return !same(readPath(overridden, path), incomingValue)\n  })\n}\n\n/** Reads a dotted path, understanding the `field[key]` segments keyed arrays use. */\nfunction readPath(value: unknown, path: string): unknown {\n  let cursor: unknown = value\n  for (const segment of path.match(/[^.[\\]]+/g) ?? []) {\n    if (Array.isArray(cursor)) {\n      const field = arrayKeyField(cursor)\n      cursor = field\n        ? cursor.find(\n            (entry) => (entry as Record<string, unknown>)[field] === segment,\n          )\n        : undefined\n      continue\n    }\n    if (!isPlainObject(cursor)) return undefined\n    cursor = cursor[segment]\n  }\n  return cursor\n}\n"],"names":["stableStringify","OVERRIDE_DELETE","ARTIFACT_OVERRIDE_FIELD","KEY_FIELDS","isPlainObject","value","Array","isArray","Object","getPrototypeOf","prototype","same","a","b","isDeleteSentinel","isKeyedArrayPatch","arrayKeyField","length","every","field","keys","map","entry","key","Set","size","keyedArrayPatch","keyedBy","entries","order","undefined","resolveOverride","base","patch","resolve","resolveKeyedArray","merged","resolved","source","keyOf","push","present","has","added","rank","Map","index","get","sort","diffOverride","edited","child","keyed","diffKeyedArray","String","baseByKey","editedKeys","includes","natural","filter","reordered","overridePaths","prefix","flatMap","isEmptyOverride","values","isStorablePatch","canOverrideArtifact","provenance","state","ok","reason","updatable","overrideWriteValue","baseSha256","meta","updatedAt","updatedBy","readArtifactOverride","doc","stored","sha","resolveArtifactContent","content","override","overrideConflicts","incoming","overridden","path","baseValue","readPath","incomingValue","cursor","segment","match","find"],"mappings":"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"}