@grafloria/element 0.3.20 → 0.3.21

package/src/libs/renderer/src/export/vnode-serializer.js

@@ -1,344 +0,0 @@
-"use strict";
-// VNode → XML string. The headless sibling of `vnode/patch.ts`.
-//
-// The patcher turns a VNode tree into live DOM; this turns the SAME tree into a
-// string, with ZERO DOM: no `document`, no `XMLSerializer`, no `innerHTML`. It
-// runs in plain Node, in a worker, in an SSR pass. That is the whole point of the
-// card: one VNode contract, two consumers, identical picture.
-//
-// It shares THE prop → attribute mapping with the patcher (`attrNameForProp`,
-// `serializeStyle`) so the two cannot drift.
-//
-// Three things this does that the patcher does not:
-//
-//   1. FLATTENS the stylesheet. The patcher can rely on the injected
-//      `var(--grafloria-*)` stylesheet being in the document; a file cannot. A
-//      {@link ClassStyleResolver} turns each element's class list into concrete
-//      presentation attributes, inserted at the correct point of the CSS priority
-//      order (see below).
-//
-//   2. DROPS live-pipeline-only attributes. `data-grafloria-instance` (the CSS scope)
-//      and `container-id` (the foreignObject component-injection handle) are both
-//      derived from PROCESS-GLOBAL COUNTERS. They mean nothing in a file, and
-//      keeping them would make the output depend on how many renderers/nodes the
-//      process happened to create first — i.e. it would destroy determinism.
-//
-//   3. TRANSLATES `filter: blur(Npx)` into a real `<filter>` def. The renderer's
-//      node shadow uses the CSS filter shorthand, which browsers accept on SVG
-//      but standalone rasterizers (resvg / librsvg / Inkscape) do not. Emitting an
-//      feGaussianBlur def keeps shadows in the exported picture.
-//
-// CSS PRIORITY ORDER — reproduced exactly, then COLLAPSED:
-//     presentation attribute  <  author stylesheet rule  <  inline style
-// The winner of that order is emitted as a presentation attribute and the `style`
-// attribute is dropped, so every property appears exactly once, in the form the
-// widest range of SVG consumers understands. (HTML inside a foreignObject is the
-// exception — HTML has no presentation attributes, so there the `style` attribute
-// is kept verbatim.)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeAttr = escapeAttr;
-exports.escapeText = escapeText;
-exports.serializeVNode = serializeVNode;
-const patch_1 = require("../vnode/patch");
-/**
- * Props that address the LIVE pipeline, not the picture. Both are minted from
- * process-global counters, so serializing them would make byte-identical output
- * impossible across processes.
- */
-const DROPPED_PROPS = new Set(['containerId', 'data-grafloria-instance']);
-/** `blur(4px)` / `blur(4)` → the radius in px. */
-const CSS_BLUR = /^blur\(\s*([\d.]+)(?:px)?\s*\)$/;
-/** XML-escape an attribute value. */
-function escapeAttr(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
-/** XML-escape text content. */
-function escapeText(value) {
-    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
-/** Split a `class` string into its tokens. */
-function classList(className) {
-    if (typeof className !== 'string' || className.trim() === '')
-        return [];
-    return className.trim().split(/\s+/);
-}
-/**
- * Turn `filter: blur(4px)` into a real SVG filter def and return the `url(#…)`
- * reference. CSS `blur(r)` is a Gaussian blur of std-deviation r/2.
- *
- * The def id is derived from the radius alone → the same radius always yields the
- * same id (determinism), and N shadows share ONE def.
- */
-function translateBlurFilter(value, extraDefs) {
-    const match = CSS_BLUR.exec(value.trim());
-    if (!match)
-        return value; // not a blur shorthand — pass through untouched
-    const radius = Number(match[1]);
-    const id = `grafloria-blur-${String(radius).replace('.', '_')}`;
-    if (!extraDefs.has(id)) {
-        extraDefs.set(id, `<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%">` +
-            `<feGaussianBlur stdDeviation="${radius / 2}"/>` +
-            `</filter>`);
-    }
-    return `url(#${id})`;
-}
-/**
- * Serialize ONE VNode (and its subtree) to an XML string.
- *
- * Pure: same VNode in, same string out — no ambient state, no DOM, no clock, no
- * randomness. Attribute order follows prop insertion order, which the renderer
- * builds deterministically, so two calls on the same tree are byte-identical.
- */
-function serializeVNode(vnode, options = {}) {
-    var _a, _b, _c, _d;
-    const warnings = (_a = options.warnings) !== null && _a !== void 0 ? _a : [];
-    const extraDefs = (_b = options.extraDefs) !== null && _b !== void 0 ? _b : new Map();
-    const foMode = (_c = options.foreignObject) !== null && _c !== void 0 ? _c : 'serialize';
-    const dom = options.fidelity === 'dom';
-    if (vnode.type === 'foreignObject') {
-        return serializeForeignObject(vnode, Object.assign(Object.assign({}, options), { warnings, extraDefs }), foMode);
-    }
-    const { attrs, text, raw } = elementAttrs(vnode, options, extraDefs, options.html === true);
-    const children = ((_d = vnode.children) !== null && _d !== void 0 ? _d : []).filter(isRenderable);
-    // A standalone file needs the namespace declared; an SSR snapshot needs it too,
-    // because the client parses the markup before the patcher adopts it.
-    if (options.standalone && !attrs.has('xmlns') && !options.html) {
-        attrs.set('xmlns', patch_1.SVG_NS);
-    }
-    // Children are serialized as SVG unless we have crossed into a foreignObject.
-    // `standalone` is a ROOT-only concern — never inherit it.
-    const childOpts = Object.assign(Object.assign({}, options), { warnings, extraDefs, standalone: false });
-    const open = `<${vnode.type}${renderAttrs(attrs)}`;
-    // `textContent` OWNS the element's content (the patcher has the same rule):
-    // elements that render through the prop never also declare children.
-    if (text !== undefined) {
-        return `${open}>${escapeText(text)}</${vnode.type}>`;
-    }
-    // Markup, emitted verbatim (see `innerHTML` above). Escaping it would print the
-    // tags instead of rendering them.
-    if (raw !== undefined) {
-        return `${open}>${raw}</${vnode.type}>`;
-    }
-    if (children.length === 0) {
-        // Under 'dom' fidelity always write the long form: the patcher builds
-        // `<g></g>`, and the snapshot the client parses should read the same.
-        return dom ? `${open}></${vnode.type}>` : `${open}/>`;
-    }
-    const inner = children
-        .map(child => isVNodeChild(child)
-        ? serializeVNode(child, childOpts)
-        : escapeText(String(child)))
-        .join('');
-    return `${open}>${inner}</${vnode.type}>`;
-}
-/**
- * foreignObject: the honest story.
- *
- * The VNode tree carries only what the RENDERER declared — for component nodes
- * that is an empty XHTML `<div>` shell whose real content is mounted into the
- * live DOM by the host framework, and which the patcher deliberately never
- * touches again. Headless, that content simply does not exist.
- *
- *   'serialize'   (default) emit the `<foreignObject>` and whatever children the
- *                 VNode declares. Faithful to the contract, and lossless for
- *                 trees that DO declare HTML children. Warns, because (a) the
- *                 host-mounted content is not in the tree and (b) essentially no
- *                 non-browser SVG rasterizer implements foreignObject at all.
- *   'placeholder' replace it with a dashed rect of the same geometry, so a server
- *                 thumbnail shows a box where the component is instead of a hole.
- *   'omit'        drop it.
- *
- * `captureForeignObject` is the escape hatch: a caller WITH a live DOM can hand
- * back the mounted markup and get a faithful export.
- */
-function serializeForeignObject(vnode, options, mode) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const { warnings } = options;
-    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-    if (mode === 'omit') {
-        warnings.push('foreignObject dropped (foreignObject: "omit")');
-        return '';
-    }
-    if (mode === 'placeholder') {
-        warnings.push('foreignObject replaced by a placeholder rect (foreignObject: "placeholder")');
-        return (`<rect x="${(_b = props.x) !== null && _b !== void 0 ? _b : 0}" y="${(_c = props.y) !== null && _c !== void 0 ? _c : 0}" ` +
-            `width="${(_d = props.width) !== null && _d !== void 0 ? _d : 0}" height="${(_e = props.height) !== null && _e !== void 0 ? _e : 0}" ` +
-            `fill="none" stroke="#94a3b8" stroke-width="1" stroke-dasharray="4,4" ` +
-            `class="grafloria-foreign-placeholder"/>`);
-    }
-    // The <foreignObject> element itself is SVG; its CHILDREN are HTML.
-    const { attrs } = elementAttrs(vnode, options, options.extraDefs, false);
-    const open = `<foreignObject${renderAttrs(attrs)}`;
-    const captured = (_f = options.captureForeignObject) === null || _f === void 0 ? void 0 : _f.call(options, vnode);
-    if (captured !== undefined) {
-        return `${open}>${captured}</foreignObject>`;
-    }
-    warnings.push('foreignObject serialized from the VNode tree only — host-mounted HTML/components are NOT in the tree ' +
-        '(pass captureForeignObject to supply it). Note that most non-browser SVG rasterizers ignore foreignObject entirely.');
-    const children = ((_g = vnode.children) !== null && _g !== void 0 ? _g : []).filter(isRenderable);
-    if (children.length === 0)
-        return `${open}/>`;
-    // Children are XHTML from here down.
-    const htmlOptions = Object.assign(Object.assign({}, options), { html: true });
-    const inner = children
-        .map(child => isVNodeChild(child) ? serializeVNode(child, htmlOptions) : escapeText(String(child)))
-        .join('');
-    return `${open}>${inner}</foreignObject>`;
-}
-/**
- * Declarations that only exist in CSS. They have no presentation-attribute
- * equivalent, and none of them means anything in a still picture.
- */
-const CSS_ONLY_DECLS = new Set([
-    'transition',
-    'cursor',
-    'will-change',
-    'animation',
-    'animation-name',
-    'animation-duration',
-    'animation-direction',
-    'animation-iteration-count',
-    'animation-timing-function',
-    'user-select',
-    'transform-origin',
-]);
-/** `'fill: red; stroke-width: 2'` (or the object form) → `{ fill: 'red', 'stroke-width': '2' }`. */
-function parseStyleDecls(style) {
-    const out = {};
-    const serialized = (0, patch_1.serializeStyle)(style); // handles BOTH forms the renderer emits
-    if (!serialized)
-        return out;
-    for (const part of serialized.split(';')) {
-        const colon = part.indexOf(':');
-        if (colon < 0)
-            continue;
-        const prop = part.slice(0, colon).trim();
-        const value = part.slice(colon + 1).trim();
-        if (prop && value)
-            out[prop] = value;
-    }
-    return out;
-}
-/**
- * Build an element's FULLY RESOLVED attribute map.
- *
- * The cascade is applied in CSS priority order …
- *
- *   1. props            → presentation attributes (lowest)
- *   2. class rules      → OVERWRITE them (an author rule beats a presentation attr)
- *   3. inline `style`   → OVERWRITES both (highest)
- *
- * … and then every winner is emitted as a PRESENTATION ATTRIBUTE, with no `style`
- * attribute left behind.
- *
- * WHY collapse to attributes rather than keep the winning value in a `style=`:
- * a standalone file is read by things that are not browsers, and presentation
- * attributes are the most universally understood form there is. Leaving
- * `fill="#ffffff" style="fill: #123456"` on an element would render correctly in
- * a browser and WRONG (theme white instead of the node's own red) in any consumer
- * that skips inline CSS — which is the exact class of bug this card exists to
- * kill. One property, one value, one place.
- */
-function elementAttrs(vnode, options, extraDefs, html) {
-    var _a;
-    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-    const attrs = new Map();
-    let text;
-    let raw;
-    let inline = {};
-    // 'dom': describe the DOM the patcher would build, verbatim. No dropping, no
-    // flattening, no filter translation — the client HAS the stylesheet, and any
-    // difference here is a hydration mismatch (torn-down + rebuilt nodes = a flash).
-    const dom = options.fidelity === 'dom';
-    for (const key of Object.keys(props)) {
-        const value = props[key];
-        if (value === null || value === undefined)
-            continue;
-        // Event handlers are not attributes. Stringifying a function into the output
-        // would emit a JS source dump as an attribute value.
-        if (typeof value === 'function')
-            continue;
-        // Live-pipeline attributes: meaningless in a file, and minted from process-global
-        // counters, so keeping them would make the bytes depend on how many renderers the
-        // process happened to build first. In a DOM snapshot they must SURVIVE — the CSS
-        // scope (`data-grafloria-instance`) and the component-mount handle both depend on them.
-        if (!dom && DROPPED_PROPS.has(key))
-            continue;
-        if (key === 'textContent') {
-            text = String(value);
-            continue;
-        }
-        // `innerHTML` OWNS the element's content — the patcher assigns it to
-        // `el.innerHTML`, so it is MARKUP, not an attribute value (HTML edge labels,
-        // Card 5). Kebab-casing it like any other prop would emit
-        // `inner-h-t-m-l="&lt;b&gt;…"`: an escaped attribute nobody reads, and an empty
-        // label in every exported file and every server render.
-        if (key === 'innerHTML') {
-            raw = String(value);
-            continue;
-        }
-        if (key === 'style') {
-            // HTML has no presentation attributes: keep the style attribute verbatim.
-            // Same for a DOM snapshot — the patcher writes `style`, so we must too.
-            if (html || dom) {
-                const serialized = (0, patch_1.serializeStyle)(value);
-                if (serialized)
-                    attrs.set('style', serialized);
-            }
-            else {
-                inline = parseStyleDecls(value);
-            }
-            continue;
-        }
-        if (key === 'filter' && !dom) {
-            attrs.set('filter', translateBlurFilter(String(value), extraDefs));
-            continue;
-        }
-        attrs.set((0, patch_1.attrNameForProp)(key), String(value));
-    }
-    if (dom) {
-        // The patcher mirrors the VNode key into the DOM as `data-vnode-key`; a snapshot
-        // that omitted it would present a different attribute set on every keyed element.
-        if (vnode.key !== undefined && vnode.key !== null) {
-            attrs.set('data-vnode-key', String(vnode.key));
-        }
-        return { attrs, text, raw };
-    }
-    // Inside a foreignObject the host's CSS owns the content — we neither know nor
-    // flatten it.
-    if (html)
-        return { attrs, text, raw };
-    // (2) the stylesheet layer, flattened
-    const resolver = options.classStyles;
-    if (resolver) {
-        for (const [prop, value] of Object.entries(resolver(classList(props['className'])))) {
-            attrs.set(prop, value);
-        }
-    }
-    // (3) the element's own inline style — the cascade's winner
-    for (const [prop, value] of Object.entries(inline)) {
-        if (CSS_ONLY_DECLS.has(prop))
-            continue;
-        attrs.set(prop, prop === 'filter' ? translateBlurFilter(value, extraDefs) : value);
-    }
-    return { attrs, text, raw };
-}
-function renderAttrs(attrs) {
-    let out = '';
-    for (const [name, value] of attrs) {
-        out += ` ${name}="${escapeAttr(value)}"`;
-    }
-    return out;
-}
-/** Empty child slots (the fallout of conditional children) — same rule as the patcher. */
-function isRenderable(child) {
-    return child !== null && child !== undefined && child !== false;
-}
-function isVNodeChild(child) {
-    return !!child && typeof child === 'object' && typeof child.type === 'string';
-}
-//# sourceMappingURL=vnode-serializer.js.map

package/src/libs/renderer/src/ext/capabilities.d.ts

@@ -1,178 +0,0 @@
-/**
- * ============================================================================
- * Card 0 — the typed CAPABILITY accessors
- * ============================================================================
- *
- * An extension never receives the engine, the renderer, or a raw registry. It
- * receives a set of narrow, typed capability objects — and ONLY the ones its
- * manifest declared (Card 7). That is the least-privilege rule, and it is what
- * makes an extension's blast radius readable from its manifest alone.
- *
- * Every `register*` here returns a {@link Disposer}, and every disposer RESTORES
- * the previous registration rather than merely deleting the key — so an
- * extension that overrode a built-in gives it back on unload.
- *
- * These are FACADES. Not one of them reimplements a registry: they delegate to
- * the real ones (shape-registry, edge-templates, RoutingEngine, TemplateRegistry,
- * CustomAnimationRegistry, and Wave 6's link-pipeline), adding only the disposer
- * + restore semantics the underlying registries never had.
- */
-import type { DiagramEngine, NodeTemplate, TemplateRegistry } from '@grafloria/engine';
-import type { IRouter } from '@grafloria/engine';
-import type { ShapeDefinition } from '../svg/shape-registry';
-import type { PathGeometry, PathShapeOptions } from '../svg/shape-registry';
-import type { LinkTemplate, LabelTemplate, MarkerDefinition } from '../svg/edge-templates';
-import type { CustomAnimationDefinition } from '../services/custom-animation-registry';
-import type { AnchorFn, ConnectionPointFn, ConnectorFn } from './link-pipeline';
-import type { Disposer } from './disposable';
-import type { Portal, PortalOptions, ViewportPortal } from './portal';
-import type { CanvasTool, ConnectionValidator } from './tools';
-/** The names an extension may request. Mirrors the keys of {@link ExtensionCapabilities}. */
-export type CapabilityName = 'shapes' | 'links' | 'routers' | 'templates' | 'animations' | 'tools' | 'panels';
-/** Contribute node geometry. Wraps the (already unified) shape registry. */
-export interface ShapeCapability {
-    /** Register a full shape definition. */
-    register(type: string, definition: Omit<ShapeDefinition, 'type'> & {
-        type?: string;
-    }): Disposer;
-    /** Register a shape from an SVG path (boundary + port anchors auto-derived). */
-    registerPath(type: string, geometry: PathGeometry, options?: PathShapeOptions): Disposer;
-    has(type: string): boolean;
-    list(): string[];
-}
-/** Contribute link visuals + the four link-pipeline stages. */
-export interface LinkCapability {
-    /** Whole-link VNode template (`link.style.template`). */
-    registerTemplate(name: string, template: LinkTemplate): Disposer;
-    /** Label VNode template (`label.template`). */
-    registerLabelTemplate(name: string, template: LabelTemplate): Disposer;
-    /** Arrowhead / marker (`arrowHead.type`). */
-    registerMarker(name: string, definition: MarkerDefinition): Disposer;
-    /** Polyline → SVG path `d` (`link.connector`). */
-    registerConnector(name: string, connector: ConnectorFn): Disposer;
-    /** Per-end attachment point (`link.metadata.sourceAnchor` / `targetAnchor`). */
-    registerAnchor(name: string, anchor: AnchorFn): Disposer;
-    /** Whole-link, two-ended attachment strategy (`link.metadata.connectionPoint`). */
-    registerConnectionPoint(name: string, strategy: ConnectionPointFn): Disposer;
-    listConnectors(): string[];
-    listAnchors(): string[];
-    listConnectionPoints(): string[];
-}
-/** Contribute routing algorithms. Wraps `RoutingEngine.registerRouter`. */
-export interface RouterCapability {
-    register(name: string, router: IRouter): Disposer;
-    list(): string[];
-    has(name: string): boolean;
-}
-/** Contribute reusable node templates. Wraps the engine's TemplateRegistry. */
-export interface TemplateCapability {
-    register(template: NodeTemplate): Disposer;
-    list(): NodeTemplate[];
-    has(id: string): boolean;
-}
-/** Contribute named animations. Wraps CustomAnimationRegistry. */
-export interface AnimationCapability {
-    register(definition: CustomAnimationDefinition): Disposer;
-    has(name: string): boolean;
-    list(): CustomAnimationDefinition[];
-}
-/** Contribute interaction tools + connection validation (Card 5). */
-export interface ToolCapability {
-    /**
-     * Register (or REPLACE, by name) a canvas tool. Replacing `'node-drag'` with
-     * your own is the point: the built-ins are registrations, not privileged code.
-     */
-    register(tool: CanvasTool): Disposer;
-    /** Veto connections. All registered validators must pass. */
-    registerConnectionValidator(validator: ConnectionValidator): Disposer;
-    list(): string[];
-    has(id: string): boolean;
-}
-/**
- * Contribute on-canvas UI (Card 6). This is the ONLY capability that hands back
- * a DOM element, and it is scoped to the diagram's own layers — an extension
- * cannot reach the rest of the page through it.
- */
-export interface PanelCapability {
-    /** A floating panel pinned to the viewport (does not pan/zoom). */
-    createPanel(options?: PortalOptions): Portal;
-    /** Content that lives IN the diagram (pans/zooms with the canvas). */
-    createViewportPanel(options?: {
-        x?: number;
-        y?: number;
-        className?: string;
-        style?: string;
-    }): ViewportPortal;
-    /** World-space, but held at a constant on-screen size. */
-    createCounterScaledPanel(options?: {
-        x?: number;
-        y?: number;
-        className?: string;
-        style?: string;
-    }): ViewportPortal;
-}
-/**
- * The full capability set. An extension's `activate()` receives a PARTIAL of
- * this — exactly the keys its manifest declared.
- */
-export interface ExtensionCapabilities {
-    shapes: ShapeCapability;
-    links: LinkCapability;
-    routers: RouterCapability;
-    templates: TemplateCapability;
-    animations: AnimationCapability;
-    tools: ToolCapability;
-    panels: PanelCapability;
-}
-/**
- * What an extension is given at activation, beyond its capabilities: a scoped
- * logger, its own resolved manifest, and a disposal bag. Deliberately NOT the
- * engine — see Card 7.
- */
-export interface ExtensionContext<C extends CapabilityName = CapabilityName> {
-    /** Only the capabilities the manifest declared. */
-    readonly capabilities: Pick<ExtensionCapabilities, C>;
-    /** The extension's own id. */
-    readonly id: string;
-    /**
-     * Anything pushed here is disposed with the extension. Use it for your own
-     * timers/listeners; registry registrations are tracked automatically.
-     */
-    onDispose(disposer: Disposer): void;
-}
-/**
- * The host's own view of the world. Passed to the capability factories so they
- * can reach the real registries. NOT exposed to extensions.
- */
-export interface HostBindings {
-    engine: DiagramEngine;
-    /**
-     * The registry every contribution is written into. Pass `diagram.registry` and
-     * this host's extensions contribute to THAT DIAGRAM ONLY.
-     *
-     * Absent means the PROCESS-GLOBAL registries, which is what every host did
-     * before per-diagram registries existed and remains the right answer for an
-     * app-wide plugin. It is also why two hosts on one page used to fight: both
-     * wrote the same `badge`, the second won, and the first one's `dispose()`
-     * restored "no badge" over the top of the second's registration.
-     */
-    registry?: import('./diagram-registry').DiagramRegistry;
-    /**
-     * The engine's node-template registry.
-     *
-     * MUST be passed explicitly: `TemplateRegistry` is constructed with an
-     * `EventBus` and is NOT reachable from `DiagramEngine` (there is no
-     * `getTemplateRegistry()`), so the host cannot find it on its own. An
-     * extension declaring the `templates` capability is REJECTED when this is
-     * absent — rather than handed a capability object that would throw on use.
-     */
-    templateRegistry?: TemplateRegistry;
-    /** The diagram root element — panels attach here. May be absent (headless). */
-    root?: HTMLElement;
-    /** The camera-transformed HTML layer — world-space panels attach here. */
-    htmlLayer?: HTMLElement;
-    /** The camera, for counter-scaled panels. */
-    viewport?: import('../viewport/viewport-controller').ViewportController;
-    /** Ask the host to repaint (a contributed shape/connector changes the picture). */
-    requestRender?: () => void;
-}

package/src/libs/renderer/src/ext/capabilities.js

@@ -1,22 +0,0 @@
-"use strict";
-/**
- * ============================================================================
- * Card 0 — the typed CAPABILITY accessors
- * ============================================================================
- *
- * An extension never receives the engine, the renderer, or a raw registry. It
- * receives a set of narrow, typed capability objects — and ONLY the ones its
- * manifest declared (Card 7). That is the least-privilege rule, and it is what
- * makes an extension's blast radius readable from its manifest alone.
- *
- * Every `register*` here returns a {@link Disposer}, and every disposer RESTORES
- * the previous registration rather than merely deleting the key — so an
- * extension that overrode a built-in gives it back on unload.
- *
- * These are FACADES. Not one of them reimplements a registry: they delegate to
- * the real ones (shape-registry, edge-templates, RoutingEngine, TemplateRegistry,
- * CustomAnimationRegistry, and Wave 6's link-pipeline), adding only the disposer
- * + restore semantics the underlying registries never had.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=capabilities.js.map

package/src/libs/renderer/src/ext/capability-factory.d.ts

@@ -1,44 +0,0 @@
-/**
- * ============================================================================
- * Card 0 — the FACADE. This is where capability objects meet the real registries.
- * ============================================================================
- *
- * Read this file as the answer to "did they rewrite the registries?" — no. Every
- * method below is a delegation to the registry that already existed, wrapped in
- * exactly two things it did not have:
- *
- *   1. a DISPOSER, and
- *   2. RESTORE-ON-DISPOSE (put back what was there before, don't just delete).
- *
- * `buildCapabilities` also enforces the grant: it materialises ONLY the keys the
- * manifest declared. An extension that did not ask for `routers` does not get a
- * `routers` object it could call — the property is absent, not merely typed away.
- *
- * ---------------------------------------------------------------------------
- * WHOSE REGISTRY — the thing that used to be missing
- * ---------------------------------------------------------------------------
- * Every delegation below now goes through `bindings.registry`, which is
- * `diagram.registry` when the host was bound to one and the process-global
- * registry otherwise. Both are the SAME class (see `diagram-registry.ts`), so
- * there is one implementation of restore-on-dispose rather than one per scope.
- *
- * That single indirection is the whole per-diagram isolation fix. Before it,
- * two hosts on one page wrote the same module-global map: the second
- * registration silently repainted the first diagram, and the first host's
- * `dispose()` — faithfully restoring what was there before IT registered —
- * deleted the second diagram's shape out from under it.
- *
- * NOT YET ROUTED: `tools` and `registerConnectionValidator`. Those registries are
- * read on the INTERACTION path (`resolveTool` on pointerdown, `isValidConnection`
- * during snapping), not inside the render pass, so scoping their storage without
- * also scoping those four read sites would make a scoped tool invisible — a
- * worse bug than the one being fixed. They are still process-global and still
- * collide between diagrams; see the note on `tools` below.
- */
-import type { CapabilityName, ExtensionCapabilities, HostBindings } from './capabilities';
-import type { DisposableStore } from './disposable';
-/**
- * Build the capability objects for ONE extension, tracking every registration in
- * that extension's own {@link DisposableStore}.
- */
-export declare function buildCapabilities(granted: readonly CapabilityName[], bindings: HostBindings, store: DisposableStore): Partial<ExtensionCapabilities>;