@dev-sergeev/datalab-kit 0.1.2 → 0.1.4

package/node_modules/@zigai/pi-extension-internals/dist/editor-enhancer-registry.d.ts

@@ -0,0 +1,21 @@
+export type EditorFactory<Args extends readonly unknown[], Editor> = (...args: Args) => Editor;
+export type EditorEnhancer<Args extends readonly unknown[], Editor> = (editor: Editor, ...args: Args) => Editor;
+export type EditorEnhancerContext<Args extends readonly unknown[], Editor> = {
+    readonly hasUI: boolean;
+    readonly ui: {
+        getEditorComponent(): EditorFactory<Args, Editor> | undefined;
+        setEditorComponent(factory: EditorFactory<Args, Editor> | undefined): void;
+    };
+};
+export type EditorEnhancerHandle<Args extends readonly unknown[], Editor> = {
+    update(enhancer: EditorEnhancer<Args, Editor>): void;
+    dispose(): void;
+};
+/**
+ * Registers one keyed editor transformation in the shared editor factory stack.
+ *
+ * The key must come from `Symbol.for(...)` so independently bundled copies and extension
+ * reloads replace the same registration. The first registration owns the fallback factory;
+ * later registrations compose enhancers without changing that fallback.
+ */
+export declare function registerEditorEnhancer<Args extends readonly unknown[], Editor>(ctx: EditorEnhancerContext<Args, Editor>, key: symbol, createDefaultEditor: EditorFactory<Args, Editor>, enhancer: EditorEnhancer<Args, Editor>): EditorEnhancerHandle<Args, Editor>;

package/node_modules/@zigai/pi-extension-internals/dist/editor-enhancer-registry.js

@@ -0,0 +1,233 @@
+const EDITOR_ENHANCER_PROTOCOL_VERSION = 1;
+const EDITOR_ENHANCER_PROTOCOL = Symbol.for("zigai.pi-tweaks.editor-enhancer-protocol-version");
+const EDITOR_ENHANCER_REGISTRY = Symbol.for("zigai.pi-tweaks.editor-enhancer-registry");
+const EDITOR_ENHANCER_FACTORY = Symbol.for("zigai.pi-tweaks.editor-enhancer-factory");
+function isUnknownDataDescriptor(descriptor) {
+    return descriptor !== undefined && Object.hasOwn(descriptor, "value");
+}
+/** Reads untrusted protocol data written by another bundled package copy. */
+// oxlint-disable-next-line antislop/no-object-parameters -- Protocol data may be attached to any Pi UI or factory object.
+function getOwnDataDescriptor(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (!isUnknownDataDescriptor(descriptor))
+        return undefined;
+    return descriptor;
+}
+function isNonNullObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isNumber(value) {
+    return typeof value === "number";
+}
+function isPropertyKey(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+function isGlobalSymbol(value) {
+    return typeof value === "symbol" && Symbol.keyFor(value) !== undefined;
+}
+// oxlint-disable-next-line antislop/no-object-parameters -- Enhancer records are intentionally structural protocol objects.
+function hasOwnFunctionProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
+        return false;
+    const value = descriptor.value;
+    return typeof value === "function";
+}
+function hasValidEnhancerEntries(entries, legacy) {
+    for (const [key, entry] of entries) {
+        if (legacy) {
+            if (!isPropertyKey(key))
+                return false;
+        }
+        else if (!isGlobalSymbol(key)) {
+            return false;
+        }
+        if (!isNonNullObject(entry))
+            return false;
+        if (!hasOwnFunctionProperty(entry, "enhancer"))
+            return false;
+    }
+    return true;
+}
+function readRegistry(ui) {
+    const recordValue = getOwnDataDescriptor(ui, EDITOR_ENHANCER_REGISTRY)?.value;
+    if (recordValue === undefined)
+        return undefined;
+    if (!isNonNullObject(recordValue)) {
+        throw new TypeError("Incompatible editor enhancer registry");
+    }
+    const record = recordValue;
+    const version = getOwnDataDescriptor(record, EDITOR_ENHANCER_PROTOCOL)?.value;
+    if (version !== undefined && version !== EDITOR_ENHANCER_PROTOCOL_VERSION) {
+        let versionLabel = `invalid-${Object.prototype.toString.call(version).slice(8, -1).toLowerCase()}`;
+        if (isNumber(version))
+            versionLabel = version.toString();
+        throw new TypeError(`Unsupported editor enhancer protocol version ${versionLabel}`);
+    }
+    const baseFactory = getOwnDataDescriptor(record, "baseFactory")?.value;
+    const defaultFactory = getOwnDataDescriptor(record, "defaultFactory")?.value;
+    const enhancers = getOwnDataDescriptor(record, "enhancers")?.value;
+    const factory = getOwnDataDescriptor(record, "factory")?.value;
+    if ((baseFactory !== undefined && typeof baseFactory !== "function") ||
+        typeof defaultFactory !== "function" ||
+        !(enhancers instanceof Map) ||
+        !hasValidEnhancerEntries(enhancers, version === undefined) ||
+        typeof factory !== "function" ||
+        getOwnDataDescriptor(factory, EDITOR_ENHANCER_FACTORY)?.value !== true) {
+        throw new TypeError("Incompatible editor enhancer registry");
+    }
+    if (version === undefined &&
+        !Reflect.defineProperty(record, EDITOR_ENHANCER_PROTOCOL, {
+            configurable: true,
+            value: EDITOR_ENHANCER_PROTOCOL_VERSION,
+        })) {
+        throw new TypeError("Unable to mark legacy editor enhancer registry as protocol v1");
+    }
+    // SAFETY: The checks above validate every runtime field shared between independently
+    // bundled protocol copies. Generic arguments are fixed by the owning Pi UI instance.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- SAFETY: Version, factories, map entries and factory marker are checked; the owning UI fixes generic editor arguments, which TypeScript cannot recover from cross-bundle symbol descriptors.
+    return record;
+}
+function markSharedFactory(factory) {
+    if (!Reflect.defineProperty(factory, EDITOR_ENHANCER_FACTORY, {
+        value: true,
+    })) {
+        throw new TypeError("Unable to mark the shared editor enhancer factory");
+    }
+}
+function isCurrentSharedFactory(factory, registry) {
+    return (factory !== undefined &&
+        factory === registry.factory &&
+        getOwnDataDescriptor(factory, EDITOR_ENHANCER_FACTORY)?.value === true);
+}
+function activateRegistry(ui, registry) {
+    const current = ui.getEditorComponent();
+    if (!isCurrentSharedFactory(current, registry)) {
+        registry.baseFactory = current;
+    }
+    ui.setEditorComponent(registry.factory);
+}
+/**
+ * Registers one keyed editor transformation in the shared editor factory stack.
+ *
+ * The key must come from `Symbol.for(...)` so independently bundled copies and extension
+ * reloads replace the same registration. The first registration owns the fallback factory;
+ * later registrations compose enhancers without changing that fallback.
+ */
+export function registerEditorEnhancer(ctx, key, createDefaultEditor, enhancer) {
+    if (Symbol.keyFor(key) === undefined) {
+        throw new TypeError("Editor enhancer keys must be created with Symbol.for(...)");
+    }
+    if (!ctx.hasUI) {
+        return {
+            update() { },
+            dispose() { },
+        };
+    }
+    let created = false;
+    let registry = readRegistry(ctx.ui);
+    if (registry === undefined) {
+        const enhancers = new Map();
+        const createdRegistry = {
+            [EDITOR_ENHANCER_PROTOCOL]: EDITOR_ENHANCER_PROTOCOL_VERSION,
+            baseFactory: ctx.ui.getEditorComponent(),
+            defaultFactory: createDefaultEditor,
+            enhancers,
+            factory: (...args) => {
+                let editor = createdRegistry.baseFactory?.(...args) ??
+                    createdRegistry.defaultFactory(...args);
+                for (const entry of enhancers.values()) {
+                    editor = entry.enhancer(editor, ...args);
+                }
+                return editor;
+            },
+        };
+        markSharedFactory(createdRegistry.factory);
+        if (!Reflect.defineProperty(ctx.ui, EDITOR_ENHANCER_REGISTRY, {
+            configurable: true,
+            value: createdRegistry,
+        })) {
+            throw new TypeError("Unable to store the editor enhancer registry");
+        }
+        registry = createdRegistry;
+        created = true;
+    }
+    const previousEntry = registry.enhancers.get(key);
+    const previousBase = registry.baseFactory;
+    const entry = { enhancer };
+    registry.enhancers.set(key, entry);
+    try {
+        activateRegistry(ctx.ui, registry);
+    }
+    catch (cause) {
+        if (previousEntry === undefined)
+            registry.enhancers.delete(key);
+        else
+            registry.enhancers.set(key, previousEntry);
+        registry.baseFactory = previousBase;
+        if (created &&
+            getOwnDataDescriptor(ctx.ui, EDITOR_ENHANCER_REGISTRY)?.value === registry &&
+            !Reflect.deleteProperty(ctx.ui, EDITOR_ENHANCER_REGISTRY)) {
+            throw new TypeError("Unable to roll back the editor enhancer registry", { cause });
+        }
+        if (cause instanceof Error) {
+            throw cause;
+        }
+        throw new Error("Unable to activate the editor enhancer registry", { cause });
+    }
+    let disposed = false;
+    return {
+        update(nextEnhancer) {
+            if (disposed || registry.enhancers.get(key) !== entry) {
+                return;
+            }
+            const previousEnhancer = entry.enhancer;
+            const previousBase = registry.baseFactory;
+            entry.enhancer = nextEnhancer;
+            try {
+                activateRegistry(ctx.ui, registry);
+            }
+            catch (cause) {
+                entry.enhancer = previousEnhancer;
+                registry.baseFactory = previousBase;
+                throw cause;
+            }
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            if (registry.enhancers.get(key) !== entry) {
+                disposed = true;
+                return;
+            }
+            if (registry.enhancers.size !== 1) {
+                const previousEntries = new Map(registry.enhancers);
+                registry.enhancers.delete(key);
+                try {
+                    if (isCurrentSharedFactory(ctx.ui.getEditorComponent(), registry)) {
+                        activateRegistry(ctx.ui, registry);
+                    }
+                }
+                catch (cause) {
+                    registry.enhancers.clear();
+                    for (const [previousKey, previousEntry] of previousEntries) {
+                        registry.enhancers.set(previousKey, previousEntry);
+                    }
+                    throw cause;
+                }
+                disposed = true;
+                return;
+            }
+            if (isCurrentSharedFactory(ctx.ui.getEditorComponent(), registry)) {
+                ctx.ui.setEditorComponent(registry.baseFactory);
+            }
+            if (getOwnDataDescriptor(ctx.ui, EDITOR_ENHANCER_REGISTRY)?.value === registry &&
+                !Reflect.deleteProperty(ctx.ui, EDITOR_ENHANCER_REGISTRY)) {
+                throw new TypeError("Unable to remove the editor enhancer registry");
+            }
+            registry.enhancers.delete(key);
+            disposed = true;
+        },
+    };
+}

package/node_modules/@zigai/pi-extension-internals/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { registerEditorEnhancer } from "./editor-enhancer-registry.ts";
+export type { EditorEnhancer, EditorEnhancerContext, EditorEnhancerHandle, EditorFactory, } from "./editor-enhancer-registry.ts";
+export { installKeyedLinkedMethodPatch, installLinkedMethodPatch, installLinkedRenderPatch, } from "./linked-method-patch.ts";
+export type { KeyedLinkedMethodPatchHandle, LinkedMethod, LinkedMethodPatchHandle, } from "./linked-method-patch.ts";
+export { loadPiInternalModule, loadPiRuntimeModule, warnPiInternalPatchUnavailable, } from "./pi-internal-import.ts";
+export type { PiInternalModuleLoadOptions } from "./pi-internal-import.ts";

package/node_modules/@zigai/pi-extension-internals/dist/index.js

@@ -0,0 +1,3 @@
+export { registerEditorEnhancer } from "./editor-enhancer-registry.js";
+export { installKeyedLinkedMethodPatch, installLinkedMethodPatch, installLinkedRenderPatch, } from "./linked-method-patch.js";
+export { loadPiInternalModule, loadPiRuntimeModule, warnPiInternalPatchUnavailable, } from "./pi-internal-import.js";

package/node_modules/@zigai/pi-extension-internals/dist/linked-method-patch.d.ts

@@ -0,0 +1,34 @@
+export type LinkedMethod<Instance, Args extends unknown[], Result> = (this: Instance, ...args: Args) => Result;
+export type LinkedMethodPatchHandle<Instance, Args extends unknown[], Result> = {
+    /** The method immediately below this patch when it was installed. */
+    readonly predecessor: LinkedMethod<Instance, Args, Result>;
+    readonly patched: LinkedMethod<Instance, Args, Result>;
+    dispose(): void;
+};
+/** Uses the target as `this` when a method does not declare an explicit receiver. */
+type MethodInstance<Target, Method> = Method extends (this: infer Instance, ...args: infer _Args) => infer _Result ? unknown extends Instance ? Target : Instance : never;
+type MethodArgs<Method> = Method extends (this: infer _Instance, ...args: infer Args) => infer _Result ? Args : never;
+type MethodResult<Method> = Method extends (this: infer _Instance, ...args: infer _Args) => infer Result ? Result : never;
+type ExtractedLinkedMethod<Target, Method> = LinkedMethod<MethodInstance<Target, Method>, MethodArgs<Method>, MethodResult<Method>>;
+/**
+ * Installs one removable method transform whose predecessor remains dynamically linked.
+ *
+ * This low-level operation intentionally installs a new layer on every call. Use
+ * `installKeyedLinkedMethodPatch` when an extension needs idempotent reload behavior.
+ * Independent layers may be disposed in any order without retaining stale closures.
+ */
+export declare function installLinkedMethodPatch<Target extends object, Key extends keyof Target>(target: Target, key: Key, transform: (predecessor: ExtractedLinkedMethod<Target, Target[Key]>) => ExtractedLinkedMethod<Target, Target[Key]>): LinkedMethodPatchHandle<MethodInstance<Target, Target[Key]>, MethodArgs<Target[Key]>, MethodResult<Target[Key]>>;
+export type KeyedLinkedMethodPatchHandle<Policy, Instance, Args extends unknown[], Result> = LinkedMethodPatchHandle<Instance, Args, Result> & {
+    update(policy: Policy): void;
+};
+/**
+ * Installs or updates one globally keyed linked method patch.
+ *
+ * The marker must come from `Symbol.for(...)`. Reinstalling the same marker updates its policy
+ * without adding another method layer, including when another bundled package copy installed it.
+ */
+export declare function installKeyedLinkedMethodPatch<Target extends object, Key extends keyof Target, Policy>(target: Target, key: Key, marker: symbol, initialPolicy: Policy, transform: (predecessor: ExtractedLinkedMethod<Target, Target[Key]>, getPolicy: () => Policy) => ExtractedLinkedMethod<Target, Target[Key]>): KeyedLinkedMethodPatchHandle<Policy, MethodInstance<Target, Target[Key]>, MethodArgs<Target[Key]>, MethodResult<Target[Key]>>;
+export declare function installLinkedRenderPatch<Target extends object & {
+    render: unknown;
+}>(target: Target, transform: (predecessor: ExtractedLinkedMethod<Target, Target["render"]>) => ExtractedLinkedMethod<Target, Target["render"]>): LinkedMethodPatchHandle<MethodInstance<Target, Target["render"]>, MethodArgs<Target["render"]>, MethodResult<Target["render"]>>;
+export {};

package/node_modules/@zigai/pi-extension-internals/dist/linked-method-patch.js

@@ -0,0 +1,272 @@
+const PATCH_PREDECESSOR = Symbol.for("zigai.pi-tweaks.render-patch-predecessor");
+const PATCH_PREDECESSOR_DESCRIPTOR = Symbol.for("zigai.pi-tweaks.render-patch-predecessor-descriptor");
+const PATCH_PROTOCOL_VERSION = 1;
+const PATCH_PROTOCOL = Symbol.for("zigai.pi-tweaks.render-patch-protocol-version");
+function isUnknownDataDescriptor(descriptor) {
+    return descriptor !== undefined && Object.hasOwn(descriptor, "value");
+}
+/** Reads untrusted metadata written by another bundled package copy. */
+// oxlint-disable-next-line antislop/no-object-parameters -- Metadata may be attached to any callable object.
+function getOwnDataDescriptor(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (!isUnknownDataDescriptor(descriptor))
+        return undefined;
+    return descriptor;
+}
+function isNonNullObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isNumber(value) {
+    return typeof value === "number";
+}
+function getLinkedPredecessor(method) {
+    const version = getOwnDataDescriptor(method, PATCH_PROTOCOL)?.value;
+    if (version !== undefined && version !== PATCH_PROTOCOL_VERSION) {
+        let versionLabel = `invalid-${Object.prototype.toString.call(version).slice(8, -1).toLowerCase()}`;
+        if (isNumber(version))
+            versionLabel = version.toString();
+        throw new Error(`Unsupported linked method patch protocol version ${versionLabel}`);
+    }
+    const predecessor = getOwnDataDescriptor(method, PATCH_PREDECESSOR)?.value;
+    if (typeof predecessor !== "function") {
+        return undefined;
+    }
+    // SAFETY: installLinkedMethodPatch writes only a method with the same signature under
+    // this process-wide symbol, and the runtime check proves the reflected value is callable.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- SAFETY: The versioned linked-patch protocol stores the same method signature; the callable check validates the reflected value, but TypeScript cannot retain generics through symbol descriptors.
+    return predecessor;
+}
+function getPredecessorDescriptor(method) {
+    const descriptor = getOwnDataDescriptor(method, PATCH_PREDECESSOR_DESCRIPTOR)?.value;
+    if (descriptor === undefined)
+        return undefined;
+    if (!isNonNullObject(descriptor)) {
+        throw new Error("Linked method patch has invalid predecessor descriptor metadata");
+    }
+    return descriptor;
+}
+function defineLinkedMetadata(method, predecessor, predecessorDescriptor, key) {
+    const metadata = [
+        [PATCH_PREDECESSOR, { configurable: true, value: predecessor, writable: true }],
+        [
+            PATCH_PREDECESSOR_DESCRIPTOR,
+            { configurable: true, value: predecessorDescriptor, writable: true },
+        ],
+        [PATCH_PROTOCOL, { configurable: true, value: PATCH_PROTOCOL_VERSION }],
+    ];
+    for (const [metadataKey, descriptor] of metadata) {
+        if (!Reflect.defineProperty(method, metadataKey, descriptor)) {
+            Reflect.deleteProperty(method, PATCH_PREDECESSOR);
+            Reflect.deleteProperty(method, PATCH_PREDECESSOR_DESCRIPTOR);
+            Reflect.deleteProperty(method, PATCH_PROTOCOL);
+            throw new TypeError(`Unable to attach linked patch metadata for ${String(key)}`);
+        }
+    }
+}
+function updateLinkedPredecessor(method, predecessor, predecessorDescriptor) {
+    if (!Reflect.set(method, PATCH_PREDECESSOR, predecessor) ||
+        !Reflect.set(method, PATCH_PREDECESSOR_DESCRIPTOR, predecessorDescriptor)) {
+        throw new Error("Unable to rewire linked method patch predecessor");
+    }
+}
+/**
+ * Installs one removable method transform whose predecessor remains dynamically linked.
+ *
+ * This low-level operation intentionally installs a new layer on every call. Use
+ * `installKeyedLinkedMethodPatch` when an extension needs idempotent reload behavior.
+ * Independent layers may be disposed in any order without retaining stale closures.
+ */
+export function installLinkedMethodPatch(target, key, transform) {
+    const candidate = target[key];
+    if (typeof candidate !== "function") {
+        throw new TypeError(`Unable to patch non-function property ${String(key)}`);
+    }
+    // SAFETY: Target[Key] determines Method's this, arguments, and result types, while the
+    // runtime check proves the indexed value is callable. TypeScript cannot retain that
+    // conditional relationship after narrowing an indexed generic property.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- SAFETY: Target[Key] supplies the exact method signature and candidate is checked callable; TypeScript loses that conditional indexed relationship after the unknown boundary.
+    const original = candidate;
+    const originalDescriptor = Object.getOwnPropertyDescriptor(target, key);
+    let patched;
+    const dynamicPredecessor = function (...args) {
+        const predecessor = getLinkedPredecessor(patched);
+        if (predecessor === undefined) {
+            throw new Error("Linked method patch lost its predecessor");
+        }
+        return predecessor.apply(this, args);
+    };
+    const transformed = transform(dynamicPredecessor);
+    if (typeof transformed !== "function") {
+        throw new TypeError(`Method transform for ${String(key)} returned a non-function`);
+    }
+    patched = transformed;
+    if (patched === original ||
+        Object.hasOwn(patched, PATCH_PREDECESSOR) ||
+        Object.hasOwn(patched, PATCH_PREDECESSOR_DESCRIPTOR) ||
+        Object.hasOwn(patched, PATCH_PROTOCOL)) {
+        throw new TypeError(`Method transform for ${String(key)} returned an installed method`);
+    }
+    if (!Object.isExtensible(patched)) {
+        throw new TypeError(`Method transform for ${String(key)} returned a non-extensible function`);
+    }
+    defineLinkedMetadata(patched, original, originalDescriptor, key);
+    let installed = false;
+    try {
+        installed = Reflect.set(target, key, patched) && target[key] === patched;
+    }
+    finally {
+        if (!installed) {
+            Reflect.deleteProperty(patched, PATCH_PREDECESSOR);
+            Reflect.deleteProperty(patched, PATCH_PREDECESSOR_DESCRIPTOR);
+            Reflect.deleteProperty(patched, PATCH_PROTOCOL);
+        }
+    }
+    if (!installed) {
+        throw new TypeError(`Unable to patch method ${String(key)}`);
+    }
+    let disposed = false;
+    return {
+        predecessor: original,
+        patched,
+        dispose() {
+            if (disposed)
+                return;
+            const predecessor = getLinkedPredecessor(patched);
+            if (predecessor === undefined) {
+                throw new Error("Linked method patch lost its predecessor");
+            }
+            const predecessorDescriptor = getPredecessorDescriptor(patched);
+            if (target[key] === patched) {
+                let restored;
+                if (predecessorDescriptor === undefined) {
+                    restored = Reflect.deleteProperty(target, key);
+                }
+                else {
+                    restored = Reflect.defineProperty(target, key, predecessorDescriptor);
+                }
+                if (!restored) {
+                    throw new Error(`Unable to restore method ${String(key)}`);
+                }
+                disposed = true;
+                return;
+            }
+            const successor = target[key];
+            if (typeof successor !== "function") {
+                disposed = true;
+                return;
+            }
+            // SAFETY: A callable value at the patched key participates in the linked-method
+            // protocol only through getLinkedPredecessor's symbol validation. This cast lets
+            // that validation preserve Method's signature across the dynamically linked chain.
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- SAFETY: This callable is only traversed through version-checked linked metadata, never invoked; TypeScript cannot carry the installed method's signature through a reflected successor.
+            let current = successor;
+            const visited = new Set();
+            for (;;) {
+                if (visited.has(current)) {
+                    throw new Error(`Unable to dispose cyclic method patch chain for ${String(key)}`);
+                }
+                visited.add(current);
+                const next = getLinkedPredecessor(current);
+                if (next === undefined) {
+                    disposed = true;
+                    return;
+                }
+                if (next === patched) {
+                    updateLinkedPredecessor(current, predecessor, predecessorDescriptor);
+                    disposed = true;
+                    return;
+                }
+                current = next;
+            }
+        },
+    };
+}
+const KEYED_PATCH_PROTOCOL_VERSION = 1;
+const KEYED_PATCH_PROTOCOL = Symbol.for("zigai.pi-tweaks.keyed-method-patch-protocol-version");
+// oxlint-disable-next-line antislop/no-object-parameters -- Protocol handles are structural objects from another bundle copy.
+function hasOwnFunctionProperty(target, key) {
+    return typeof getOwnDataDescriptor(target, key)?.value === "function";
+}
+/* oxlint-disable antislop/no-object-parameters -- This parses a protocol record created by another bundle copy. */
+function readKeyedPatchHandle(record, methodKey) {
+    const version = getOwnDataDescriptor(record, KEYED_PATCH_PROTOCOL)?.value;
+    if (version !== KEYED_PATCH_PROTOCOL_VERSION) {
+        let versionLabel = `invalid-${Object.prototype.toString.call(version).slice(8, -1).toLowerCase()}`;
+        if (isNumber(version))
+            versionLabel = version.toString();
+        throw new TypeError(`Unsupported keyed method patch protocol version ${versionLabel}`);
+    }
+    if (getOwnDataDescriptor(record, "methodKey")?.value !== methodKey) {
+        throw new TypeError("Keyed method patch marker is already used for another method");
+    }
+    const handle = getOwnDataDescriptor(record, "handle")?.value;
+    if (!isNonNullObject(handle) ||
+        !hasOwnFunctionProperty(handle, "predecessor") ||
+        !hasOwnFunctionProperty(handle, "patched") ||
+        !hasOwnFunctionProperty(handle, "update") ||
+        !hasOwnFunctionProperty(handle, "dispose")) {
+        throw new TypeError("Incompatible keyed method patch handle");
+    }
+    // SAFETY: The shared record version and complete callable handle shape were validated.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- SAFETY: Protocol version, method key and every callable handle member are validated; the globally keyed installer owns the policy/signature relationship that TypeScript cannot recover from descriptors.
+    return handle;
+}
+/* oxlint-enable antislop/no-object-parameters */
+/**
+ * Installs or updates one globally keyed linked method patch.
+ *
+ * The marker must come from `Symbol.for(...)`. Reinstalling the same marker updates its policy
+ * without adding another method layer, including when another bundled package copy installed it.
+ */
+export function installKeyedLinkedMethodPatch(target, key, marker, initialPolicy, transform) {
+    if (Symbol.keyFor(marker) === undefined) {
+        throw new TypeError("Keyed method patch markers must be created with Symbol.for(...)");
+    }
+    const installedRecord = getOwnDataDescriptor(target, marker)?.value;
+    if (installedRecord !== undefined) {
+        if (!isNonNullObject(installedRecord)) {
+            throw new TypeError("Incompatible keyed method patch record");
+        }
+        const handle = readKeyedPatchHandle(installedRecord, key);
+        handle.update(initialPolicy);
+        return handle;
+    }
+    let currentPolicy = initialPolicy;
+    const patch = installLinkedMethodPatch(target, key, (predecessor) => transform(predecessor, () => currentPolicy));
+    let disposed = false;
+    let record;
+    const handle = {
+        predecessor: patch.predecessor,
+        patched: patch.patched,
+        update(policy) {
+            if (!disposed)
+                currentPolicy = policy;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            patch.dispose();
+            if (getOwnDataDescriptor(target, marker)?.value === record &&
+                !Reflect.deleteProperty(target, marker)) {
+                throw new TypeError(`Unable to remove keyed method patch ${String(marker)}`);
+            }
+            disposed = true;
+        },
+    };
+    record = {
+        [KEYED_PATCH_PROTOCOL]: KEYED_PATCH_PROTOCOL_VERSION,
+        methodKey: key,
+        handle,
+    };
+    if (!Reflect.defineProperty(target, marker, {
+        configurable: true,
+        value: record,
+    })) {
+        patch.dispose();
+        throw new TypeError(`Unable to store keyed method patch ${String(marker)}`);
+    }
+    return handle;
+}
+export function installLinkedRenderPatch(target, transform) {
+    return installLinkedMethodPatch(target, "render", transform);
+}

package/node_modules/@zigai/pi-extension-internals/dist/pi-internal-import.d.ts

@@ -0,0 +1,11 @@
+export type PiInternalModuleLoadOptions<T> = {
+    readonly scope: string;
+    readonly feature: string;
+    readonly parse: (module: unknown) => T | undefined;
+};
+/** Reports a disabled best-effort patch without interrupting extension startup. */
+export declare function warnPiInternalPatchUnavailable(scope: string, feature: string, cause?: unknown): void;
+/** Loads and parses an unsupported Pi internal module, degrading to undefined on failure. */
+export declare function loadPiInternalModule<T>(relativePath: string, options: PiInternalModuleLoadOptions<T>): Promise<T | undefined>;
+/** Loads a runtime-owned export from Pi's bundle before its unbundled fallback module. */
+export declare function loadPiRuntimeModule<T>(fallbackRelativePath: string, options: PiInternalModuleLoadOptions<T>): Promise<T | undefined>;