@kywi-software/core 0.10.0 → 0.12.0

package/dist/admin/layout-editor/component-fork.d.ts

@@ -0,0 +1,224 @@
+import type { LayoutDocument, LayoutSection, ModuleNode, VariantContainer } from '../../layout/types.js';
+import { type ComponentDetachSource, type ComponentInstance, type ComponentPlacementLookup, type ComponentRef, type ComponentRefKind } from '../../layout/component-refs.js';
+/**
+ * component-fork.ts
+ * The pure half of the save fork (kywi-cms#147 T4): which linked instances the
+ * author has EDITED, and what each of the two answers writes.
+ *
+ * THE FEATURE, in one paragraph. A linked instance is editable in place like any
+ * other content. At save time the editor notices that an instance no longer
+ * matches the component it points at and asks: **Save and update all instances**
+ * (the edit becomes the component's definition — every instance everywhere,
+ * published pages included, renders it from the next request on) or **Save to
+ * this page only** (this instance stops being an instance: it keeps what the
+ * author sees and drops the link). There are no per-prop overrides in v1 — the
+ * link is strict (spec decision 5) — so those two are the only coherent answers,
+ * and the editor must not persist a third.
+ *
+ * Everything here is pure and layout-shaped: no fetch, no React, no dialog. The
+ * hook that drives it lives in `use-component-fork.tsx`.
+ */
+/** One linked instance whose content no longer matches its baseline. */
+export interface LinkedInstanceEdit {
+    componentId: string;
+    nodeId: string;
+    kind: ComponentRefKind;
+    /** The instance as the editor holds it now. */
+    instance: ComponentInstance;
+    /** The instance as it was when the editor and the server last agreed. */
+    baseline: ComponentInstance;
+}
+/**
+ * A baseline for a placement the STORED document does not have.
+ *
+ * Consulted only for links that appeared during this session — a node just
+ * connected by "save as component", or a component just placed from the picker.
+ * Both write the definition (or a clone of it) at that moment, so the instance
+ * starts out matching its component and only a LATER edit makes it dirty; the
+ * shell records what it looked like at that moment and hands it back through
+ * this. Without it, "save as component, then fix the typo you just noticed"
+ * would save the typo fix into the page as a divergent fallback copy that the
+ * page never renders — an edit silently lost, which is the worst outcome this
+ * feature can produce.
+ */
+export type LinkedInstanceBaseline = (ref: ComponentRef) => ComponentInstance | null | undefined;
+/**
+ * Which linked instances in `current` differ from their stored selves.
+ *
+ * WHAT COUNTS AS AN EDIT OF THE INSTANCE (and what deliberately does not):
+ *
+ *  - **Anything inside a linked section or container counts.** The whole subtree
+ *    IS the instance: a section component resolves wholesale, so retyping a
+ *    heading three levels down is an edit of the component's content, not of the
+ *    page's.
+ *  - **Position does not count.** Which region a linked node sits in, and where
+ *    among its siblings, belongs to the PAGE, not to the component — identity is
+ *    (componentId, nodeId), so moving or reordering an instance finds the same
+ *    baseline and compares equal. Same for the placement's own `id`.
+ *  - **A variant container's `experimentId` / `winnerId` do not count.** They
+ *    bind THIS page's container to THIS page's experiment run, which is why
+ *    `applyVariantContainerPlacement` gives the placement's binding priority over
+ *    the definition's, and why the rail keeps them editable on a linked
+ *    container. Counting them would open the fork on "declare arm B the winner"
+ *    and then write nothing.
+ *  - **A link that only exists in `current` is not an edit.** It was created this
+ *    session, from the definition — see {@link LinkedInstanceBaseline} for the
+ *    one case where a baseline is supplied anyway.
+ *  - **A link that only exists in `stored` is not an edit.** It was detached (or
+ *    deleted) this session; there is no instance left to ask about.
+ *
+ * `stored` is the last-saved document (the editor's `originalLayout`), not the
+ * document the session opened with: after a successful save the baseline moves,
+ * so a second round of edits forks again.
+ *
+ * The comparison is over the STORED node, not over what it renders, so it is
+ * conservative in one direction: typing a prop and then typing the component's
+ * own value back leaves an override that reads the same as the definition, and
+ * that still counts as an edit. The fork then asks a question whose "update all"
+ * answer writes a byte-identical definition. Conservative is the right way round
+ * here — the failure it rules out is a MISSED edit, which loses work.
+ */
+export declare function diffLinkedInstances(stored: LayoutDocument | null | undefined, current: LayoutDocument | null | undefined, fallbackBaseline?: LinkedInstanceBaseline): LinkedInstanceEdit[];
+/**
+ * Do these two instances hold the same CONTENT — everything the component owns,
+ * nothing the placement owns? See {@link diffLinkedInstances} for the rules and
+ * why each exclusion is there.
+ */
+export declare function linkedInstanceContentEquals(a: ComponentInstance, b: ComponentInstance): boolean;
+/** What the two writes of an update-all look like, built from ONE source of truth. */
+export interface ForkUpdateAll {
+    /**
+     * The `definition` for `PUT /components/:id`. Deliberately the only field the
+     * fork sends: `moduleType` decides how the definition is READ, and a linked
+     * node's own `type` is not a reliable source for it (a component placed from
+     * the palette picker is a `component` placeholder node), so a fork that sent
+     * one could quietly re-type the component.
+     */
+    definition: Record<string, unknown>;
+    /**
+     * What the page stores in place of the edited node once the definition holds
+     * the edit — a clean instance again, so the strict link holds and the next
+     * diff sees no edit. Built from the same flattened node as `definition`, which
+     * is what makes "the fallback copy shows what the link resolves to" true.
+     */
+    cleanInstance: ModuleNode | LayoutSection | VariantContainer;
+}
+/**
+ * Turn an edited instance into the component definition it should become, plus
+ * the clean instance the page keeps. Returns null when that cannot be done
+ * honestly (see the module case).
+ *
+ * THE INVERSE OF PLACEMENT, kind by kind:
+ *
+ *  - **module** — the node holds only OVERRIDES (a clean instance holds nothing
+ *    but the link), so the definition is what this placement currently RENDERS:
+ *    `resolveModulePlacement(node, resolved)`, the very function the renderer and
+ *    the canvas preview call. That needs the current definition, so an
+ *    unresolvable component returns null rather than shipping the overrides alone
+ *    — which would silently wipe every prop the author never touched. The caller
+ *    offers only "this page only" in that case.
+ *  - **section** — the node holds the WHOLE content (its inline copy is the
+ *    definition's, as edited), so the definition is that content with the link
+ *    dropped and the PLACEMENT'S SCOPING undone (`unapplySectionPlacement`, the
+ *    exact inverse of the `applySectionPlacement` the copy was materialised
+ *    with). That needs the current definition too — for its root id, and because
+ *    a definition the editor could not read is one whose copy it cannot vouch
+ *    for — so an unresolvable component returns null here as well.
+ *  - **variantContainer** — as a section, minus the experiment binding: the
+ *    definition keeps whatever binding it was SAVED with and never absorbs this
+ *    placement's. `buildConnectedVariantContainerNode` drops the definition's
+ *    binding when creating a placement precisely so a component cannot enrol a
+ *    second page in the first page's experiment; the inverse has to hold, or
+ *    "update all" would do exactly that in reverse. Arms, audiences, weights and
+ *    `mode` ARE the component's, and travel. An unresolvable container source
+ *    returns null rather than emitting a definition with NO binding at all,
+ *    which would silently clear the component's own experiment (T4 review, I3).
+ *
+ * Nested links are materialised first (`flattenComponentLinks`) because the API
+ * refuses a definition that links to another component — the same reason
+ * "save as component" flattens. The instance's OWN link is dropped before
+ * flattening runs, or the flattening would materialise it and hand back the
+ * STORED definition, throwing away the very edit being saved.
+ *
+ * IDS ARE STABLE ACROSS ROUNDS (kywi-cms#147 T4 review, C1). `cleanInstance` is
+ * built by re-applying the NEW definition to this placement rather than by keeping
+ * the edited node, so it is byte-identical to what the next editor session would
+ * refresh the copy to (`refreshComponentCopies`), and the definition's own
+ * ids never accumulate the placement's scope. The compatibility surface documented
+ * at `rekeyResolvedVariantContainer` still applies to ids the author's edit
+ * introduces or removes, but an update-all that changes only content now leaves
+ * every other instance's rendered ids exactly where they were.
+ */
+export declare function buildUpdateAll(edit: LinkedInstanceEdit, options?: {
+    /** The component's current stored definition, as materialisation reads it. */
+    source?: ComponentDetachSource | null | undefined;
+    /** Resolves links INSIDE the selection, for the flattening. */
+    resolveLink?: ComponentPlacementLookup;
+}): ForkUpdateAll | null;
+/**
+ * Would an update-all built from this edit's BASELINE reproduce the component's
+ * current definition — or has the definition moved on since this page stored its
+ * copy? (kywi-cms#147 T4 review, C1, the belt.)
+ *
+ * WHY THIS IS NEEDED EVEN WITH THE REFRESH (`refreshComponentCopies` in
+ * `layout/component-refs.ts`). That pass brings every
+ * copy in line the moment the library loads, which makes staleness impossible for
+ * the ordinary session. It cannot help when there IS no definition to refresh
+ * from — the library fetch failed, the row was deleted — or when the library
+ * arrived after the document was already dirty, where refreshing would clobber the
+ * author's edits and is therefore skipped. In those cases the baseline is whatever
+ * the page happened to store, and building the definition out of it would revert
+ * every newer edit of that component everywhere. So update-all is WITHDRAWN and
+ * the owner is told to save locally and re-edit from an up-to-date page.
+ *
+ * MODULES ARE EXEMPT, and not by oversight: a module placement stores only
+ * OVERRIDES, and its definition is built as `resolveModulePlacement(node,
+ * currentDefinition)` — the current definition is read on the spot, so untouched
+ * props come from it and nothing can be reverted. There is no copy to be stale.
+ *
+ * The comparison ignores ids at every structural level. An unrefreshed baseline
+ * holds the ids its clone was given rather than the ones a fresh materialisation
+ * derives, and refusing update-all over an id difference — with content that
+ * agrees — would withdraw the feature's whole point on a technicality.
+ */
+export declare function isBaselineStale(edit: LinkedInstanceEdit, source?: ComponentDetachSource | null | undefined): boolean;
+/**
+ * The node the page stores when the author keeps the edit here: an independent
+ * copy of WHAT THEY SEE, with the link gone.
+ *
+ * HOW THIS DIFFERS FROM THE RAIL'S "Detach from component", and why it must.
+ * Rail-detach materialises the component's CURRENT definition into the node
+ * (`detachSectionFromComponent` → `applySectionPlacement`) — the right answer
+ * there, because that node is showing the definition and detaching must not
+ * change the page. Here the node is NOT showing the definition: the author has
+ * edited it, and their edit is the whole point of the save. Materialising the
+ * stored definition would discard it. So:
+ *
+ *  - **section / container** — keep the node's current subtree, drop the link.
+ *    Nothing is flattened: a link that was nested inside this instance becomes a
+ *    real, visible placement of its own the moment the outer link goes (that is
+ *    exactly what `collectComponentRefs` starts reporting), so the index, the
+ *    usage counts and the renderer all pick it up. Flattening it would silently
+ *    turn a live link into a copy.
+ *  - **module** — the node holds only overrides, so what it renders is the
+ *    definition merged with them: `materializeModuleNode`, the canonical
+ *    materialisation the renderer and the server's detach-all share. The local
+ *    edits survive because the merge puts them on top. The `componentId` echo in
+ *    `props` is stripped: it is a link marker, and there is no link left. (An
+ *    unresolvable component degrades to the node's own props alone — again
+ *    exactly what such an instance renders today.)
+ */
+export declare function detachInstanceKeepingEdits(edit: LinkedInstanceEdit, source?: ComponentDetachSource | null | undefined): ModuleNode | LayoutSection | VariantContainer;
+/**
+ * Replace the named placements in a document, keyed by
+ * {@link componentRefKey} — the identity everything else in this feature uses.
+ *
+ * Goes through `rewriteComponentInstances` (the canonical traversal) rather than
+ * walking the tree here, so the fork can only ever rewrite nodes the instance
+ * index and the usage counts agree are placements — including the ones sitting in
+ * page variants and A/B experiment regions, which the reducer's REPLACE_* actions
+ * cannot reach (they address the ACTIVE regions only). That is why the fork
+ * applies one whole document rather than a series of node swaps.
+ */
+export declare function applyInstanceReplacements(layout: LayoutDocument, replacements: Map<string, ModuleNode | LayoutSection | VariantContainer>): LayoutDocument;
+//# sourceMappingURL=component-fork.d.ts.map

package/dist/admin/layout-editor/component-fork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-fork.d.ts","sourceRoot":"","sources":["../../../src/admin/layout-editor/component-fork.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,UAAU,EACV,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAUL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,gCAAgC,CAAA;AAGvC;;;;;;;;;;;;;;;;;GAiBG;AAIH,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,gBAAgB,CAAA;IACtB,+CAA+C;IAC/C,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,yEAAyE;IACzE,QAAQ,EAAE,iBAAiB,CAAA;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,GAAG,EAAE,YAAY,KAAK,iBAAiB,GAAG,IAAI,GAAG,SAAS,CAAA;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACzC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EAC1C,gBAAgB,CAAC,EAAE,sBAAsB,GACxC,kBAAkB,EAAE,CAsBtB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAG/F;AA4DD,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,EAAE,UAAU,GAAG,aAAa,GAAG,gBAAgB,CAAA;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,kBAAkB,EACxB,OAAO,GAAE;IACP,8EAA8E;IAC9E,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,CAAA;IACjD,+DAA+D;IAC/D,WAAW,CAAC,EAAE,wBAAwB,CAAA;CAClC,GACL,aAAa,GAAG,IAAI,CAsDtB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,kBAAkB,EACxB,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAChD,OAAO,CAeT;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,kBAAkB,EACxB,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAChD,UAAU,GAAG,aAAa,GAAG,gBAAgB,CAU/C;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,GAAG,gBAAgB,CAAC,GACvE,cAAc,CAShB"}

package/dist/admin/layout-editor/component-fork.js

@@ -0,0 +1,342 @@
+import { applySectionPlacement, applyVariantContainerPlacement, collectComponentInstances, componentRefKey, materializeModuleNode, resolveModulePlacement, rewriteComponentInstances, unapplySectionPlacement, unapplyVariantContainerPlacement, } from '../../layout/component-refs.js';
+import { flattenComponentLinks } from './component-actions.js';
+/**
+ * Which linked instances in `current` differ from their stored selves.
+ *
+ * WHAT COUNTS AS AN EDIT OF THE INSTANCE (and what deliberately does not):
+ *
+ *  - **Anything inside a linked section or container counts.** The whole subtree
+ *    IS the instance: a section component resolves wholesale, so retyping a
+ *    heading three levels down is an edit of the component's content, not of the
+ *    page's.
+ *  - **Position does not count.** Which region a linked node sits in, and where
+ *    among its siblings, belongs to the PAGE, not to the component — identity is
+ *    (componentId, nodeId), so moving or reordering an instance finds the same
+ *    baseline and compares equal. Same for the placement's own `id`.
+ *  - **A variant container's `experimentId` / `winnerId` do not count.** They
+ *    bind THIS page's container to THIS page's experiment run, which is why
+ *    `applyVariantContainerPlacement` gives the placement's binding priority over
+ *    the definition's, and why the rail keeps them editable on a linked
+ *    container. Counting them would open the fork on "declare arm B the winner"
+ *    and then write nothing.
+ *  - **A link that only exists in `current` is not an edit.** It was created this
+ *    session, from the definition — see {@link LinkedInstanceBaseline} for the
+ *    one case where a baseline is supplied anyway.
+ *  - **A link that only exists in `stored` is not an edit.** It was detached (or
+ *    deleted) this session; there is no instance left to ask about.
+ *
+ * `stored` is the last-saved document (the editor's `originalLayout`), not the
+ * document the session opened with: after a successful save the baseline moves,
+ * so a second round of edits forks again.
+ *
+ * The comparison is over the STORED node, not over what it renders, so it is
+ * conservative in one direction: typing a prop and then typing the component's
+ * own value back leaves an override that reads the same as the definition, and
+ * that still counts as an edit. The fork then asks a question whose "update all"
+ * answer writes a byte-identical definition. Conservative is the right way round
+ * here — the failure it rules out is a MISSED edit, which loses work.
+ */
+export function diffLinkedInstances(stored, current, fallbackBaseline) {
+    const storedInstances = new Map(collectComponentInstances(stored).map(instance => [componentRefKey(instance), instance]));
+    const edits = [];
+    for (const instance of collectComponentInstances(current)) {
+        const baseline = storedInstances.get(componentRefKey(instance)) ?? fallbackBaseline?.(instance) ?? null;
+        // A baseline of a different kind is not a baseline: the same node id now
+        // holds a different sort of node (a section replaced by a container, say),
+        // which is a new placement rather than an edited one.
+        if (!baseline || baseline.kind !== instance.kind)
+            continue;
+        if (linkedInstanceContentEquals(baseline, instance))
+            continue;
+        edits.push({
+            componentId: instance.componentId,
+            nodeId: instance.nodeId,
+            kind: instance.kind,
+            instance,
+            baseline,
+        });
+    }
+    return edits;
+}
+/**
+ * Do these two instances hold the same CONTENT — everything the component owns,
+ * nothing the placement owns? See {@link diffLinkedInstances} for the rules and
+ * why each exclusion is there.
+ */
+export function linkedInstanceContentEquals(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    return sameContent(instanceContent(a), instanceContent(b));
+}
+function instanceContent(instance) {
+    if (instance.kind === 'module') {
+        // `id`/`instanceId` are the placement's; the `componentId` echo in `props` is
+        // a link marker rather than content (see `resolveModulePlacement`).
+        return {
+            type: instance.node.type,
+            props: withoutComponentIdProp(instance.node.props ?? {}),
+            style: instance.node.style ?? {},
+        };
+    }
+    if (instance.kind === 'section') {
+        const { id: _placementId, componentId: _link, ...content } = instance.node;
+        return content;
+    }
+    const { id: _placementId, componentId: _link, experimentId: _thisPagesRun, winnerId: _thisPagesWinner, ...content } = instance.node;
+    return content;
+}
+/** Key order is not content: two prop maps written in different orders agree. */
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value !== null && typeof value === 'object') {
+        const source = value;
+        const out = {};
+        for (const key of Object.keys(source).sort()) {
+            // An explicitly-undefined key and a missing one are the same absence; only
+            // one of the two survives a jsonb round trip, so they must compare equal.
+            if (source[key] === undefined)
+                continue;
+            out[key] = canonical(source[key]);
+        }
+        return out;
+    }
+    return value;
+}
+function sameContent(a, b) {
+    return JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+}
+function withoutComponentIdProp(props) {
+    if (!('componentId' in props))
+        return props;
+    const { componentId: _echo, ...rest } = props;
+    return rest;
+}
+function withoutLink(node) {
+    const { componentId: _dropped, ...rest } = node;
+    return rest;
+}
+/**
+ * Turn an edited instance into the component definition it should become, plus
+ * the clean instance the page keeps. Returns null when that cannot be done
+ * honestly (see the module case).
+ *
+ * THE INVERSE OF PLACEMENT, kind by kind:
+ *
+ *  - **module** — the node holds only OVERRIDES (a clean instance holds nothing
+ *    but the link), so the definition is what this placement currently RENDERS:
+ *    `resolveModulePlacement(node, resolved)`, the very function the renderer and
+ *    the canvas preview call. That needs the current definition, so an
+ *    unresolvable component returns null rather than shipping the overrides alone
+ *    — which would silently wipe every prop the author never touched. The caller
+ *    offers only "this page only" in that case.
+ *  - **section** — the node holds the WHOLE content (its inline copy is the
+ *    definition's, as edited), so the definition is that content with the link
+ *    dropped and the PLACEMENT'S SCOPING undone (`unapplySectionPlacement`, the
+ *    exact inverse of the `applySectionPlacement` the copy was materialised
+ *    with). That needs the current definition too — for its root id, and because
+ *    a definition the editor could not read is one whose copy it cannot vouch
+ *    for — so an unresolvable component returns null here as well.
+ *  - **variantContainer** — as a section, minus the experiment binding: the
+ *    definition keeps whatever binding it was SAVED with and never absorbs this
+ *    placement's. `buildConnectedVariantContainerNode` drops the definition's
+ *    binding when creating a placement precisely so a component cannot enrol a
+ *    second page in the first page's experiment; the inverse has to hold, or
+ *    "update all" would do exactly that in reverse. Arms, audiences, weights and
+ *    `mode` ARE the component's, and travel. An unresolvable container source
+ *    returns null rather than emitting a definition with NO binding at all,
+ *    which would silently clear the component's own experiment (T4 review, I3).
+ *
+ * Nested links are materialised first (`flattenComponentLinks`) because the API
+ * refuses a definition that links to another component — the same reason
+ * "save as component" flattens. The instance's OWN link is dropped before
+ * flattening runs, or the flattening would materialise it and hand back the
+ * STORED definition, throwing away the very edit being saved.
+ *
+ * IDS ARE STABLE ACROSS ROUNDS (kywi-cms#147 T4 review, C1). `cleanInstance` is
+ * built by re-applying the NEW definition to this placement rather than by keeping
+ * the edited node, so it is byte-identical to what the next editor session would
+ * refresh the copy to (`refreshComponentCopies`), and the definition's own
+ * ids never accumulate the placement's scope. The compatibility surface documented
+ * at `rekeyResolvedVariantContainer` still applies to ids the author's edit
+ * introduces or removes, but an update-all that changes only content now leaves
+ * every other instance's rendered ids exactly where they were.
+ */
+export function buildUpdateAll(edit, options = {}) {
+    const { source, resolveLink } = options;
+    if (edit.instance.kind === 'module') {
+        if (!source || source.kind !== 'module')
+            return null;
+        const node = edit.instance.node;
+        const rendered = resolveModulePlacement(node, source);
+        return {
+            definition: {
+                props: withoutComponentIdProp(rendered.props),
+                style: { ...rendered.style },
+            },
+            cleanInstance: {
+                ...node,
+                componentId: edit.componentId,
+                props: { componentId: edit.componentId },
+                style: {},
+            },
+        };
+    }
+    if (edit.instance.kind === 'section') {
+        if (!source || source.kind !== 'section')
+            return null;
+        const placement = edit.instance.node;
+        const flattened = flattenComponentLinks(withoutLink(placement), resolveLink);
+        const definition = unapplySectionPlacement(flattened, source.section.id);
+        return {
+            definition: definition,
+            cleanInstance: {
+                ...applySectionPlacement(definition, placement),
+                componentId: edit.componentId,
+            },
+        };
+    }
+    if (!source || source.kind !== 'variantContainer')
+        return null;
+    const placement = edit.instance.node;
+    const stored = source.container;
+    const flattened = flattenComponentLinks(withoutLink(placement), resolveLink);
+    const definition = {
+        ...unapplyVariantContainerPlacement(flattened, stored.id),
+        ...(stored.experimentId !== undefined ? { experimentId: stored.experimentId } : {}),
+        ...(stored.winnerId !== undefined ? { winnerId: stored.winnerId } : {}),
+    };
+    return {
+        definition: definition,
+        // The placement keeps its own binding — that is the half of the container
+        // this page owns, and `applyVariantContainerPlacement` is where that rule
+        // lives.
+        cleanInstance: {
+            ...applyVariantContainerPlacement(definition, placement),
+            componentId: edit.componentId,
+        },
+    };
+}
+// ── Is the page's copy of the component out of date? ─────────────────────────
+/**
+ * Would an update-all built from this edit's BASELINE reproduce the component's
+ * current definition — or has the definition moved on since this page stored its
+ * copy? (kywi-cms#147 T4 review, C1, the belt.)
+ *
+ * WHY THIS IS NEEDED EVEN WITH THE REFRESH (`refreshComponentCopies` in
+ * `layout/component-refs.ts`). That pass brings every
+ * copy in line the moment the library loads, which makes staleness impossible for
+ * the ordinary session. It cannot help when there IS no definition to refresh
+ * from — the library fetch failed, the row was deleted — or when the library
+ * arrived after the document was already dirty, where refreshing would clobber the
+ * author's edits and is therefore skipped. In those cases the baseline is whatever
+ * the page happened to store, and building the definition out of it would revert
+ * every newer edit of that component everywhere. So update-all is WITHDRAWN and
+ * the owner is told to save locally and re-edit from an up-to-date page.
+ *
+ * MODULES ARE EXEMPT, and not by oversight: a module placement stores only
+ * OVERRIDES, and its definition is built as `resolveModulePlacement(node,
+ * currentDefinition)` — the current definition is read on the spot, so untouched
+ * props come from it and nothing can be reverted. There is no copy to be stale.
+ *
+ * The comparison ignores ids at every structural level. An unrefreshed baseline
+ * holds the ids its clone was given rather than the ones a fresh materialisation
+ * derives, and refusing update-all over an id difference — with content that
+ * agrees — would withdraw the feature's whole point on a technicality.
+ */
+export function isBaselineStale(edit, source) {
+    if (edit.kind === 'module')
+        return false;
+    if (edit.baseline.kind === 'section') {
+        if (source?.kind !== 'section')
+            return true;
+        return !sameContent(structuralSection(edit.baseline.node), structuralSection(applySectionPlacement(source.section, edit.baseline.node)));
+    }
+    if (edit.baseline.kind !== 'variantContainer')
+        return true;
+    if (source?.kind !== 'variantContainer')
+        return true;
+    return !sameContent(structuralContainer(edit.baseline.node), structuralContainer(applyVariantContainerPlacement(source.container, edit.baseline.node)));
+}
+/** Drop the keys that identify a node rather than describe it. */
+function withoutIdentity(node) {
+    const { id: _placementId, instanceId: _instanceId, componentId: _link, ...rest } = node;
+    return rest;
+}
+function structuralSection(section) {
+    return {
+        ...withoutIdentity(section),
+        columns: (section.columns ?? []).map(column => ({
+            ...withoutIdentity(column),
+            nodes: (column.nodes ?? []).map(node => withoutIdentity(node)),
+        })),
+    };
+}
+function structuralContainer(container) {
+    const { experimentId: _thisPagesRun, winnerId: _thisPagesWinner, ...rest } = container;
+    return {
+        ...withoutIdentity(rest),
+        defaultSections: (container.defaultSections ?? []).map(structuralSection),
+        variants: (container.variants ?? []).map(variant => ({
+            ...withoutIdentity(variant),
+            sections: (variant.sections ?? []).map(structuralSection),
+        })),
+    };
+}
+// ── "Save to this page only" ─────────────────────────────────────────────────
+/**
+ * The node the page stores when the author keeps the edit here: an independent
+ * copy of WHAT THEY SEE, with the link gone.
+ *
+ * HOW THIS DIFFERS FROM THE RAIL'S "Detach from component", and why it must.
+ * Rail-detach materialises the component's CURRENT definition into the node
+ * (`detachSectionFromComponent` → `applySectionPlacement`) — the right answer
+ * there, because that node is showing the definition and detaching must not
+ * change the page. Here the node is NOT showing the definition: the author has
+ * edited it, and their edit is the whole point of the save. Materialising the
+ * stored definition would discard it. So:
+ *
+ *  - **section / container** — keep the node's current subtree, drop the link.
+ *    Nothing is flattened: a link that was nested inside this instance becomes a
+ *    real, visible placement of its own the moment the outer link goes (that is
+ *    exactly what `collectComponentRefs` starts reporting), so the index, the
+ *    usage counts and the renderer all pick it up. Flattening it would silently
+ *    turn a live link into a copy.
+ *  - **module** — the node holds only overrides, so what it renders is the
+ *    definition merged with them: `materializeModuleNode`, the canonical
+ *    materialisation the renderer and the server's detach-all share. The local
+ *    edits survive because the merge puts them on top. The `componentId` echo in
+ *    `props` is stripped: it is a link marker, and there is no link left. (An
+ *    unresolvable component degrades to the node's own props alone — again
+ *    exactly what such an instance renders today.)
+ */
+export function detachInstanceKeepingEdits(edit, source) {
+    if (edit.instance.kind === 'module') {
+        const materialised = materializeModuleNode(edit.instance.node, source ?? { kind: 'unresolvable' }, 'drop');
+        return { ...materialised, props: withoutComponentIdProp(materialised.props ?? {}) };
+    }
+    return withoutLink(edit.instance.node);
+}
+// ── Applying the answers to the document ─────────────────────────────────────
+/**
+ * Replace the named placements in a document, keyed by
+ * {@link componentRefKey} — the identity everything else in this feature uses.
+ *
+ * Goes through `rewriteComponentInstances` (the canonical traversal) rather than
+ * walking the tree here, so the fork can only ever rewrite nodes the instance
+ * index and the usage counts agree are placements — including the ones sitting in
+ * page variants and A/B experiment regions, which the reducer's REPLACE_* actions
+ * cannot reach (they address the ACTIVE regions only). That is why the fork
+ * applies one whole document rather than a series of node swaps.
+ */
+export function applyInstanceReplacements(layout, replacements) {
+    if (replacements.size === 0)
+        return layout;
+    const take = (ref) => replacements.get(componentRefKey(ref));
+    return rewriteComponentInstances(layout, {
+        module: (node, ref) => take(ref) ?? node,
+        section: (section, ref) => take(ref) ?? section,
+        variantContainer: (container, ref) => take(ref) ?? container,
+    });
+}
+//# sourceMappingURL=component-fork.js.map

package/dist/admin/layout-editor/component-fork.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-fork.js","sourceRoot":"","sources":["../../../src/admin/layout-editor/component-fork.ts"],"names":[],"mappings":"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"}

package/dist/admin/layout-editor/editor-canvas.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import type { EditorState, EditorAction } from './editor-state.js';
-import type { InlineTextProp } from './inline-text.js';
+import type { InlineTextProp, InlineTextBindingTarget } from './inline-text.js';
+import type { ComponentAffordances } from './linked-component.js';
 /** Resolve a connected component node to its live definition for canvas preview. */
 type ComponentPreviewResolver = (componentId: string) => {
     props: Record<string, unknown>;
@@ -23,15 +24,19 @@ export interface InlineEditController {
     resetId: string | null;
     /** Bumped each time an edit session ends. */
     nonce: number;
-    /** The module type's primary text prop, or null when it has none. */
-    resolveTextProp: (moduleType: string) => InlineTextProp | null;
+    /**
+     * The element + prop a gesture inside one module's wrapper binds, or null when
+     * there is nothing safe to bind (kywi-cms#145 — see `resolveInlineBinding`).
+     */
+    resolveBinding: (moduleType: string, wrapper: HTMLElement, target: Element | null) => InlineTextBindingTarget | null;
     onActivate: (moduleId: string) => void;
-    onCommit: (moduleId: string, host: HTMLElement) => void;
+    onCommit: (moduleId: string, host: HTMLElement, prop: InlineTextProp) => void;
     onCancel: () => void;
     /**
-     * Double-click fallback for a module with no primary text prop (kywi-cms#118).
-     * Selecting is the caller's job (via the module's own `onSelect`); this only
-     * moves focus into the already-open props rail once that selection commits.
+     * Double-click fallback for a gesture with nothing safe to bind
+     * (kywi-cms#118, kywi-cms#145). Selecting is the caller's job (via the
+     * module's own `onSelect`); this only moves focus into the already-open props
+     * rail once that selection commits.
      */
     focusPropsRail: () => void;
 }
@@ -55,8 +60,24 @@ interface EditorCanvasProps {
      * chips, handles) float above it instead of boxing it into an artboard.
      */
     inPlace?: boolean;
+    /**
+     * Whether the front editor's left module-palette rail is expanded
+     * (kywi-cms#132). The rail is fixed to the viewport edge and floats over the
+     * page's left margin, so a full-width section's floating chrome renders
+     * underneath it and cannot be clicked — the chrome moves out of its way, and
+     * this is the only channel that tells it to. Meaningful in in-place mode
+     * only: the admin artboard's palette is an in-flow column.
+     */
+    paletteOpen?: boolean;
     /** Inline text editing controller, only meaningful in in-place mode. */
     inlineEdit?: InlineEditController | null;
+    /**
+     * Reusable-component chrome (kywi-cms#147): "Save as component" actions on
+     * section / module / container chrome, and the name for a linked instance's
+     * pill. Supplied by whichever shell owns the component library and the save
+     * dialog; omitted, the canvas simply renders no component chrome.
+     */
+    componentAffordances?: ComponentAffordances;
 }
 /**
  * Memoized (kywi-cms#142): the canvas re-renders on every editor-state