@floegence/redevplugin-ui 0.4.3 → 0.5.1

package/dist/trusted-parent.d.ts

@@ -2,6 +2,6 @@ export * from "./contracts.gen.js";
 export * from "./errors.js";
 export * from "./platform.js";
 export { PluginSurfaceScope, createPluginSurfaceScope } from "./surface-scope.js";
-export { PluginSurfaceHost, PluginSurfaceReloadLimiter, createReDevPluginSurfaceTransport, defaultPluginSurfaceReloadMax, defaultPluginSurfaceReloadWindowMs, isPluginRiskPlan, opaqueSurfaceDocumentSchemaVersion, pluginRiskPlanSchemaVersion, trustedParentBridgeHandshakeTranscriptSHA256, } from "./surface.js";
-export type { BridgeLifecycleEvent, MessageChannelLike, MessageEventLike, MessagePortLike, OpaqueSurfaceAsset, OpaqueSurfaceDocument, OpaqueSurfaceStyle, OpaqueSurfaceWorker, PluginConfirmationDecision, PluginConfirmationHandler, PluginConfirmationIntent, PluginConfirmationPlan, PluginMethodResult, PluginRiskEffect, PluginRiskFlag, PluginRiskPlan, PluginRiskSeverity, PluginStreamEvent, PluginSurfaceHostBootstrap, PluginSurfaceHostOptions, PluginSurfaceOpeningProgress, PluginSurfacePreparationResult, PluginSurfaceReloadDecision, PluginSurfaceReloadLimiterOptions, PluginSurfaceReloadState, PluginTrustedMethodResult, ReDevPluginSurfaceTransport, ReDevPluginSurfaceTransportOptions, TrustedParentBridgeHandshake, TrustedParentBridgeTokenRequest, WindowLike, } from "./surface.js";
-export type { FetchInitLike, FetchLike, FetchResponseLike, HostEnvelope } from "./http.js";
+export { PluginSurfaceReloadLimiter, PluginSurfaceSlot, createReDevPluginSurfaceTransport, defaultPluginSurfaceReloadMax, defaultPluginSurfaceReloadWindowMs, isPluginRiskPlan, opaqueSurfaceDocumentSchemaVersion, pluginRiskPlanSchemaVersion, trustedParentBridgeHandshakeTranscriptSHA256, } from "./surface.js";
+export type { BridgeLifecycleEvent, MessageChannelLike, MessageEventLike, MessagePortLike, OpaqueSurfaceAsset, OpaqueSurfaceDocument, OpaqueSurfaceStyle, OpaqueSurfaceWorker, PluginConfirmationDecision, PluginConfirmationHandler, PluginConfirmationIntent, PluginConfirmationPlan, PluginMethodResult, PluginRiskEffect, PluginRiskFlag, PluginRiskPlan, PluginRiskSeverity, PluginStreamEvent, PluginSurfaceHost, PluginSurfaceCloseResult, PluginSurfaceOpeningProgress, PluginSurfaceQuiesceResult, PluginSurfacePreparationResult, PluginSurfaceReloadDecision, PluginSurfaceReloadLimiterOptions, PluginSurfaceReloadState, PluginSurfaceSlotOptions, PluginSurfaceSlotState, PluginTrustedMethodResult, ReDevPluginSurfaceTransport, ReDevPluginSurfaceTransportOptions, TrustedParentBridgeHandshake, TrustedParentBridgeTokenRequest, WindowLike, } from "./surface.js";
+export type { FetchInitLike, FetchLike, FetchResponseLike, PlatformResponse } from "./http.js";

package/dist/trusted-parent.js

@@ -2,4 +2,4 @@ export * from "./contracts.gen.js";
 export * from "./errors.js";
 export * from "./platform.js";
 export { PluginSurfaceScope, createPluginSurfaceScope } from "./surface-scope.js";
-export { PluginSurfaceHost, PluginSurfaceReloadLimiter, createReDevPluginSurfaceTransport, defaultPluginSurfaceReloadMax, defaultPluginSurfaceReloadWindowMs, isPluginRiskPlan, opaqueSurfaceDocumentSchemaVersion, pluginRiskPlanSchemaVersion, trustedParentBridgeHandshakeTranscriptSHA256, } from "./surface.js";
+export { PluginSurfaceReloadLimiter, PluginSurfaceSlot, createReDevPluginSurfaceTransport, defaultPluginSurfaceReloadMax, defaultPluginSurfaceReloadWindowMs, isPluginRiskPlan, opaqueSurfaceDocumentSchemaVersion, pluginRiskPlanSchemaVersion, trustedParentBridgeHandshakeTranscriptSHA256, } from "./surface.js";

package/dist/ui-patch-validator.d.ts

@@ -0,0 +1,67 @@
+import { type OpaqueSurfaceAllowedTag } from "./opaque-surface-policy.gen.js";
+export type PluginUIAttributeValue = string | number | boolean;
+export type PluginUITextVNode = {
+    type: "text";
+    key: string;
+    text: string;
+};
+export type PluginUIElementVNode = {
+    type: "element";
+    key: string;
+    tag: OpaqueSurfaceAllowedTag;
+    attributes?: Record<string, PluginUIAttributeValue>;
+    children?: PluginUIVNode[];
+};
+export type PluginUIVNode = PluginUITextVNode | PluginUIElementVNode;
+export type PluginUISetTextOperation = {
+    type: "set_text";
+    target_key: string;
+    text: string;
+};
+export type PluginUIPatchAttributesOperation = {
+    type: "patch_attributes";
+    target_key: string;
+    set: Record<string, PluginUIAttributeValue>;
+    remove: string[];
+};
+export type PluginUIPatchControlOperation = {
+    type: "patch_control";
+    target_key: string;
+    edit_revision: number;
+    value?: string | null;
+    checked?: boolean | null;
+};
+export type PluginUIInsertChildOperation = {
+    type: "insert_child";
+    parent_key: string;
+    before_key: string | null;
+    node: PluginUIVNode;
+};
+export type PluginUIRemoveChildOperation = {
+    type: "remove_child";
+    target_key: string;
+};
+export type PluginUIMoveChildOperation = {
+    type: "move_child";
+    target_key: string;
+    parent_key: string;
+    before_key: string | null;
+};
+export type PluginUIPatchOperation = PluginUISetTextOperation | PluginUIPatchAttributesOperation | PluginUIPatchControlOperation | PluginUIInsertChildOperation | PluginUIRemoveChildOperation | PluginUIMoveChildOperation;
+export type PluginUIMountMessage = {
+    type: "redevplugin.ui.mount";
+    id: string;
+    revision: 1;
+    tree: PluginUIElementVNode;
+};
+export type PluginUIPatchMessage = {
+    type: "redevplugin.ui.patch";
+    id: string;
+    base_revision: number;
+    revision: number;
+    operations: PluginUIPatchOperation[];
+};
+export declare class PluginUIReconcileError extends Error {
+    constructor(message: string);
+}
+export declare function validatePluginUITree(tree: PluginUIVNode): PluginUIElementVNode;

package/dist/ui-patch-validator.js

@@ -0,0 +1,125 @@
+import { opaqueSurfaceAllowedTags, opaqueSurfaceGlobalAttributes, opaqueSurfaceRenderLimits, opaqueSurfaceSafeInputTypes, opaqueSurfaceTagAttributes, } from "./opaque-surface-policy.gen.js";
+export class PluginUIReconcileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PluginUIReconcileError";
+    }
+}
+const keyPattern = new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$");
+const identifierPattern = new RegExp("^[A-Za-z0-9._:-]{1,128}$");
+const opaqueHandlePattern = new RegExp("^[A-Za-z0-9_-]{8,160}$");
+const allowedTags = new Set(opaqueSurfaceAllowedTags);
+const globalAttributes = new Set(opaqueSurfaceGlobalAttributes);
+const safeInputTypes = new Set(opaqueSurfaceSafeInputTypes);
+const textNodeKeys = new Set(["type", "key", "text"]);
+const elementNodeKeys = new Set(["type", "key", "tag", "attributes", "children"]);
+const tagAttributes = new Map(Object.entries(opaqueSurfaceTagAttributes).map(([tag, attributes]) => [tag, new Set(attributes)]));
+export function validatePluginUITree(tree) {
+    if (!isElement(tree)) {
+        throw new PluginUIReconcileError("Plugin UI root must be one keyed element");
+    }
+    const keys = new Set();
+    const ancestors = new Set();
+    let nodes = 0;
+    const visit = (node, depth) => {
+        nodes += 1;
+        if (nodes > opaqueSurfaceRenderLimits.max_render_nodes || depth > opaqueSurfaceRenderLimits.max_render_depth) {
+            throw new PluginUIReconcileError("Plugin UI tree exceeds structural limits");
+        }
+        if ((!isText(node) && !isElement(node)) || ancestors.has(node)) {
+            throw new PluginUIReconcileError("Plugin UI tree must contain plain keyed acyclic VNodes");
+        }
+        if (!keyPattern.test(node.key) || keys.has(node.key)) {
+            throw new PluginUIReconcileError(`Plugin UI key is invalid or duplicated: ${String(node.key)}`);
+        }
+        keys.add(node.key);
+        if (node.type === "text") {
+            if (node.text.length > opaqueSurfaceRenderLimits.max_text_length) {
+                throw new PluginUIReconcileError("Plugin UI text exceeds limits");
+            }
+            return;
+        }
+        ancestors.add(node);
+        try {
+            if (!allowedTags.has(node.tag)) {
+                throw new PluginUIReconcileError(`Plugin UI tag is not allowed for ${node.key}`);
+            }
+            if (node.attributes !== undefined) {
+                if (!isPlainRecord(node.attributes) || Object.keys(node.attributes).length > opaqueSurfaceRenderLimits.max_attributes_per_element) {
+                    throw new PluginUIReconcileError(`Plugin UI attributes are invalid for ${node.key}`);
+                }
+                for (const [name, value] of Object.entries(node.attributes)) {
+                    if (!validAttribute(node.tag, name, value)) {
+                        throw new PluginUIReconcileError(`Plugin UI attribute ${name} is not allowed for ${node.key}`);
+                    }
+                }
+            }
+            if (node.children !== undefined) {
+                if (!Array.isArray(node.children))
+                    throw new PluginUIReconcileError(`Plugin UI children are invalid for ${node.key}`);
+                for (const child of node.children)
+                    visit(child, depth + 1);
+            }
+        }
+        finally {
+            ancestors.delete(node);
+        }
+    };
+    visit(tree, 1);
+    return tree;
+}
+function isText(value) {
+    return isPlainRecord(value) && hasExactKeys(value, textNodeKeys) &&
+        value.type === "text" && typeof value.key === "string" && typeof value.text === "string";
+}
+function isElement(value) {
+    if (!isPlainRecord(value))
+        return false;
+    return hasAllowedKeys(value, elementNodeKeys) &&
+        value.type === "element" && typeof value.key === "string" && typeof value.tag === "string";
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.size && actual.every((key) => keys.has(key));
+}
+function hasAllowedKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.has(key));
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function validAttribute(tag, name, value) {
+    const normalized = name.toLowerCase();
+    if (normalized.startsWith("on") || ["style", "src", "srcset", "href", "srcdoc", "action", "formaction"].includes(normalized)) {
+        return false;
+    }
+    if (!globalAttributes.has(normalized) && !normalized.startsWith("aria-") && !tagAttributes.get(tag)?.has(normalized)) {
+        return false;
+    }
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+        return false;
+    if (typeof value === "number" && !Number.isFinite(value))
+        return false;
+    const serialized = String(value);
+    if (normalized === "data-redevplugin-action" || normalized === "data-redevplugin-escape-action") {
+        if (!identifierPattern.test(serialized))
+            return false;
+    }
+    if (normalized === "data-redevplugin-asset-binding") {
+        if (!serialized.startsWith("asset_") || !opaqueHandlePattern.test(serialized))
+            return false;
+    }
+    if (normalized === "data-redevplugin-asset-attr" && serialized !== "src" && serialized !== "poster")
+        return false;
+    if (normalized === "data-redevplugin-canvas" && (tag !== "canvas" || !keyPattern.test(serialized)))
+        return false;
+    if (tag === "canvas" && (normalized === "width" || normalized === "height") &&
+        (!/^[1-9][0-9]{0,4}$/.test(serialized) || Number(serialized) > opaqueSurfaceRenderLimits.max_canvas_dimension))
+        return false;
+    if (tag === "input" && normalized === "type" && !safeInputTypes.has(serialized.trim().toLowerCase() || "text"))
+        return false;
+    return serialized.length <= opaqueSurfaceRenderLimits.max_attribute_value_length;
+}

package/dist/ui-reconciler.d.ts

@@ -0,0 +1,10 @@
+import { type PluginUIElementVNode, type PluginUIPatchOperation } from "./ui-patch-validator.js";
+export { PluginUIReconcileError, validatePluginUITree } from "./ui-patch-validator.js";
+export type { PluginUIAttributeValue, PluginUIElementVNode, PluginUIInsertChildOperation, PluginUIMountMessage, PluginUIMoveChildOperation, PluginUIPatchAttributesOperation, PluginUIPatchControlOperation, PluginUIPatchMessage, PluginUIPatchOperation, PluginUIRemoveChildOperation, PluginUISetTextOperation, PluginUITextVNode, PluginUIVNode, } from "./ui-patch-validator.js";
+export type PluginUIReconcileOptions = {
+    controlEditRevisions?: ReadonlyMap<string, number>;
+    transferredCanvasKeys?: ReadonlySet<string>;
+    maxOperations?: number;
+};
+export declare function reconcilePluginUITrees(current: PluginUIElementVNode, next: PluginUIElementVNode, options?: PluginUIReconcileOptions): PluginUIPatchOperation[];
+export declare function reconcileValidatedPluginUITrees(current: PluginUIElementVNode, next: PluginUIElementVNode, options?: PluginUIReconcileOptions): PluginUIPatchOperation[];

package/dist/ui-reconciler.js

@@ -0,0 +1,283 @@
+import { opaqueSurfaceRenderLimits } from "./opaque-surface-policy.gen.js";
+import { PluginUIReconcileError, validatePluginUITree, } from "./ui-patch-validator.js";
+export { PluginUIReconcileError, validatePluginUITree } from "./ui-patch-validator.js";
+const editableValueTags = new Set(["input", "textarea", "select", "option"]);
+const emptyAttributes = {};
+const maxPluginUIPatchOperations = opaqueSurfaceRenderLimits.max_patch_operations;
+export function reconcilePluginUITrees(current, next, options = {}) {
+    validatePluginUITree(current);
+    validatePluginUITree(next);
+    return reconcileValidatedPluginUITrees(current, next, options);
+}
+// Internal fast path for callers that retain trees returned by validatePluginUITree.
+export function reconcileValidatedPluginUITrees(current, next, options = {}) {
+    if (current.key !== next.key || current.tag !== next.tag) {
+        throw new PluginUIReconcileError("Plugin UI root key and tag are immutable");
+    }
+    const currentIndex = indexTree(current);
+    const nextIndex = indexTree(next);
+    const transferredCanvasKeys = options.transferredCanvasKeys ?? new Set();
+    for (const key of transferredCanvasKeys) {
+        const left = currentIndex.byKey.get(key);
+        const right = nextIndex.byKey.get(key);
+        if (!left || !right) {
+            throw new PluginUIReconcileError(`Transferred canvas ${key} cannot be removed`);
+        }
+        if (!sameNodeIdentity(left.node, right.node)) {
+            throw new PluginUIReconcileError(`Transferred canvas ${key} cannot be replaced`);
+        }
+        if (left.parentKey !== right.parentKey || left.childIndex !== right.childIndex) {
+            throw new PluginUIReconcileError(`Transferred canvas ${key} cannot be moved`);
+        }
+        if (left.node.type !== "element" || right.node.type !== "element" || !sameAttributes(left.node.attributes, right.node.attributes)) {
+            throw new PluginUIReconcileError(`Transferred canvas ${key} cannot be patched`);
+        }
+    }
+    const maxOperations = options.maxOperations ?? maxPluginUIPatchOperations;
+    if (!Number.isSafeInteger(maxOperations) || maxOperations < 1 || maxOperations > maxPluginUIPatchOperations) {
+        throw new PluginUIReconcileError(`Plugin UI maxOperations must be an integer between 1 and ${maxPluginUIPatchOperations}`);
+    }
+    const operations = [];
+    const append = (operation) => {
+        if (operations.length >= maxOperations) {
+            throw new PluginUIReconcileError("Plugin UI patch exceeds the operation limit");
+        }
+        operations.push(operation);
+    };
+    let structurallyChanged = currentIndex.byKey.size !== nextIndex.byKey.size;
+    const contentOperations = [];
+    const replacementKeys = new Set();
+    for (const key of nextIndex.order) {
+        const leftInfo = currentIndex.byKey.get(key);
+        const rightInfo = nextIndex.byKey.get(key);
+        const left = leftInfo?.node;
+        const right = rightInfo?.node;
+        if (!left || !right) {
+            structurallyChanged = true;
+            continue;
+        }
+        if (!sameNodeIdentity(left, right)) {
+            replacementKeys.add(key);
+            structurallyChanged = true;
+            continue;
+        }
+        if (leftInfo.parentKey !== rightInfo.parentKey || leftInfo.childIndex !== rightInfo.childIndex) {
+            structurallyChanged = true;
+        }
+        if (left.type === "text" && right.type === "text") {
+            if (left.text !== right.text)
+                contentOperations.push({ type: "set_text", target_key: key, text: right.text });
+        }
+        else if (left.type === "element" && right.type === "element") {
+            reconcileAttributes(left, right, options.controlEditRevisions, (operation) => contentOperations.push(operation));
+        }
+    }
+    if (replacementKeys.has(current.key)) {
+        throw new PluginUIReconcileError("Plugin UI root key and tag are immutable");
+    }
+    if (!structurallyChanged) {
+        if (contentOperations.length > maxOperations) {
+            throw new PluginUIReconcileError("Plugin UI patch exceeds the operation limit");
+        }
+        return contentOperations;
+    }
+    const removedRoots = [];
+    for (const key of currentIndex.order) {
+        if (key === current.key)
+            continue;
+        if (nextIndex.byKey.has(key) && !replacementKeys.has(key))
+            continue;
+        let ancestorKey = currentIndex.byKey.get(key)?.parentKey;
+        let coveredByRemovedAncestor = false;
+        while (ancestorKey) {
+            if (!nextIndex.byKey.has(ancestorKey) || replacementKeys.has(ancestorKey)) {
+                coveredByRemovedAncestor = true;
+                break;
+            }
+            ancestorKey = currentIndex.byKey.get(ancestorKey)?.parentKey;
+        }
+        if (!coveredByRemovedAncestor)
+            removedRoots.push(key);
+    }
+    const removedCoverage = new Set();
+    for (const key of removedRoots) {
+        collectSubtreeKeys(currentIndex, key, removedCoverage);
+        ensureCanvasStable(currentIndex, key, transferredCanvasKeys, "removed or replaced");
+        append({ type: "remove_child", target_key: key });
+    }
+    for (const operation of contentOperations) {
+        const targetKey = "target_key" in operation ? operation.target_key : undefined;
+        if (!targetKey || !removedCoverage.has(targetKey))
+            append(operation);
+    }
+    const coveredByFullInsertion = new Set();
+    for (const parentKey of nextIndex.order) {
+        if (coveredByFullInsertion.has(parentKey))
+            continue;
+        const parent = nextIndex.byKey.get(parentKey)?.node;
+        if (!parent || parent.type !== "element")
+            continue;
+        const desiredKeys = nextIndex.byKey.get(parentKey)?.childKeys ?? [];
+        const currentSequence = desiredKeys.map((key) => {
+            const currentInfo = currentIndex.byKey.get(key);
+            if (!currentInfo || removedCoverage.has(key) || currentInfo.parentKey !== parentKey)
+                return -1;
+            return currentInfo.childIndex;
+        });
+        const stablePositions = longestIncreasingSubsequencePositions(currentSequence);
+        for (let index = desiredKeys.length - 1; index >= 0; index -= 1) {
+            const key = desiredKeys[index];
+            const beforeKey = desiredKeys[index + 1] ?? null;
+            const currentInfo = currentIndex.byKey.get(key);
+            const isAvailable = Boolean(currentInfo && !removedCoverage.has(key));
+            if (!isAvailable) {
+                const node = nextIndex.byKey.get(key)?.node;
+                if (!node)
+                    throw new PluginUIReconcileError("Plugin UI insertion index is inconsistent");
+                const canInsertFullSubtree = !subtreeContainsAvailableKey(nextIndex, key, currentIndex, removedCoverage);
+                const insertion = canInsertFullSubtree ? node : shallowNode(node);
+                append({ type: "insert_child", parent_key: parentKey, before_key: beforeKey, node: insertion });
+                if (canInsertFullSubtree)
+                    collectSubtreeKeys(nextIndex, key, coveredByFullInsertion);
+                continue;
+            }
+            if (currentInfo?.parentKey !== parentKey || !stablePositions.has(index)) {
+                ensureCanvasStable(currentIndex, key, transferredCanvasKeys, "moved");
+                append({ type: "move_child", target_key: key, parent_key: parentKey, before_key: beforeKey });
+            }
+        }
+    }
+    return operations;
+}
+function indexTree(root) {
+    const byKey = new Map();
+    const order = [];
+    const visit = (node, parentKey, childIndex, depth) => {
+        const children = node.type === "element" ? node.children ?? [] : [];
+        const childKeys = children.length > 0 ? children.map((child) => child.key) : undefined;
+        byKey.set(node.key, { node, parentKey, childIndex, ...(childKeys ? { childKeys } : {}), depth });
+        order.push(node.key);
+        for (let index = 0; index < children.length; index += 1) {
+            visit(children[index], node.key, index, depth + 1);
+        }
+    };
+    visit(root, undefined, 0, 1);
+    return { byKey, order };
+}
+function reconcileAttributes(current, next, controlEditRevisions, append) {
+    const left = current.attributes;
+    const right = next.attributes;
+    let set;
+    let remove;
+    for (const name in right) {
+        const value = right[name];
+        if (!isEditableControlAttribute(current.tag, name) && left?.[name] !== value) {
+            (set ??= {})[name] = value;
+        }
+    }
+    for (const name in left) {
+        if (!isEditableControlAttribute(current.tag, name) && !(name in (right ?? emptyAttributes))) {
+            (remove ??= []).push(name);
+        }
+    }
+    if (set || remove) {
+        append({ type: "patch_attributes", target_key: current.key, set: set ?? {}, remove: remove ?? [] });
+    }
+    const valueChanged = editableValueTags.has(current.tag) && left?.value !== right?.value;
+    const checkedChanged = current.tag === "input" && left?.checked !== right?.checked;
+    if (valueChanged || checkedChanged) {
+        append({
+            type: "patch_control",
+            target_key: current.key,
+            edit_revision: controlEditRevisions?.get(current.key) ?? 0,
+            ...(valueChanged ? { value: right?.value === undefined ? null : String(right.value) } : {}),
+            ...(checkedChanged ? { checked: right?.checked === undefined ? null : Boolean(right.checked) } : {}),
+        });
+    }
+}
+function longestIncreasingSubsequencePositions(values) {
+    const tails = [];
+    const predecessors = new Array(values.length).fill(-1);
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value < 0)
+            continue;
+        let low = 0;
+        let high = tails.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if ((values[tails[middle]] ?? Infinity) < value)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low > 0)
+            predecessors[index] = tails[low - 1] ?? -1;
+        tails[low] = index;
+    }
+    const positions = new Set();
+    let cursor = tails[tails.length - 1] ?? -1;
+    while (cursor >= 0) {
+        positions.add(cursor);
+        cursor = predecessors[cursor] ?? -1;
+    }
+    return positions;
+}
+function collectSubtreeKeys(index, rootKey, output) {
+    const stack = [rootKey];
+    while (stack.length > 0) {
+        const key = stack.pop();
+        if (!key || output.has(key))
+            continue;
+        output.add(key);
+        stack.push(...(index.byKey.get(key)?.childKeys ?? []));
+    }
+}
+function subtreeContainsAvailableKey(nextIndex, rootKey, currentIndex, removedCoverage) {
+    const stack = [...(nextIndex.byKey.get(rootKey)?.childKeys ?? [])];
+    while (stack.length > 0) {
+        const key = stack.pop();
+        if (!key)
+            continue;
+        if (currentIndex.byKey.has(key) && !removedCoverage.has(key))
+            return true;
+        stack.push(...(nextIndex.byKey.get(key)?.childKeys ?? []));
+    }
+    return false;
+}
+function shallowNode(node) {
+    if (node.type === "text")
+        return node;
+    return {
+        type: "element",
+        key: node.key,
+        tag: node.tag,
+        ...(node.attributes ? { attributes: node.attributes } : {}),
+        children: [],
+    };
+}
+function ensureCanvasStable(index, rootKey, transferredCanvasKeys, action) {
+    const stack = [rootKey];
+    while (stack.length > 0) {
+        const key = stack.pop();
+        if (!key)
+            continue;
+        if (transferredCanvasKeys.has(key)) {
+            throw new PluginUIReconcileError(`Transferred canvas ${key} cannot be ${action}`);
+        }
+        stack.push(...(index.byKey.get(key)?.childKeys ?? []));
+    }
+}
+function sameNodeIdentity(left, right) {
+    return left.type === right.type && (left.type === "text" || (right.type === "element" && left.tag === right.tag));
+}
+function sameAttributes(left, right) {
+    const leftEntries = Object.entries(left ?? emptyAttributes);
+    const rightEntries = Object.entries(right ?? emptyAttributes);
+    return leftEntries.length === rightEntries.length && leftEntries.every(([name, value]) => right?.[name] === value);
+}
+function isEditableControlAttribute(tag, name) {
+    const normalized = name.toLowerCase();
+    return (normalized === "value" && editableValueTags.has(tag)) ||
+        (normalized === "checked" && tag === "input");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/redevplugin-ui",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "license": "MIT",
   "type": "module",
   "repository": {