@nodish/core 0.1.4 → 0.2.0

package/dist/src/components/types/NumberWidget.vue.d.ts

@@ -1,15 +0,0 @@
-import { Port, PortTypeDefinition, TypeWidgetSpec } from '../../store/model';
-type __VLS_Props = {
-    port: Port;
-    typeDef?: PortTypeDefinition;
-    effectiveWidget?: TypeWidgetSpec;
-    placeholder: string;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:value": (value: unknown) => any;
-    commit: () => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:value"?: ((value: unknown) => any) | undefined;
-    onCommit?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLInputElement>;
-export default _default;

package/dist/src/components/types/PortValueWidget.vue.d.ts

@@ -1,17 +0,0 @@
-import { Port, PortTypeDefinition, TypeWidgetSpec } from '../../store/model';
-type __VLS_Props = {
-    port: Port;
-    typeDef?: PortTypeDefinition;
-    effectiveWidget?: TypeWidgetSpec;
-    mode: "editable" | "readonly";
-    displayValue?: unknown;
-    placeholder: string;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:value": (value: unknown) => any;
-    commit: () => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:value"?: ((value: unknown) => any) | undefined;
-    onCommit?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/src/components/types/ReadonlyWidget.vue.d.ts

@@ -1,9 +0,0 @@
-import { Port, PortTypeDefinition, TypeWidgetSpec } from '../../store/model';
-type __VLS_Props = {
-    port: Port;
-    typeDef?: PortTypeDefinition;
-    effectiveWidget?: TypeWidgetSpec;
-    displayValue?: unknown;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
-export default _default;

package/dist/src/components/types/TextWidget.vue.d.ts

@@ -1,15 +0,0 @@
-import { Port, PortTypeDefinition, TypeWidgetSpec } from '../../store/model';
-type __VLS_Props = {
-    port: Port;
-    typeDef?: PortTypeDefinition;
-    effectiveWidget?: TypeWidgetSpec;
-    placeholder: string;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:value": (value: unknown) => any;
-    commit: () => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:value"?: ((value: unknown) => any) | undefined;
-    onCommit?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/src/components/types/registerDefaultTypeWidgets.d.ts

@@ -1,6 +0,0 @@
-/**
- * Register built-in Vue widgets for conventional `number` and `string` type ids.
- * Call once at app startup before loading packs that rely on those widgets.
- */
-export declare function registerDefaultTypeWidgets(): void;
-export { registerComponentWidget, registerTypeWidget } from './registry';

package/dist/src/components/types/registry.d.ts

@@ -1,13 +0,0 @@
-import { Component } from 'vue';
-import { PortTypeDefinition, TypeWidgetSpec } from '../../store/model';
-/**
- * Bind a Vue component to all editable ports of a type id.
- * Overrides the generic widget for that type.
- */
-export declare function registerTypeWidget(typeId: string, component: Component): void;
-/**
- * Bind a Vue component to a custom widget id
- * ({@link TypeWidgetSpec} `kind: "custom"`).
- */
-export declare function registerComponentWidget(componentId: string, component: Component): void;
-export declare function resolveTypeWidget(typeDef: PortTypeDefinition | undefined, effectiveWidget: TypeWidgetSpec | undefined, mode: "editable" | "readonly"): Component;

package/dist/src/pack/index.d.ts

@@ -1,5 +0,0 @@
-export type { DynamicPortsSpec, IOSpec, NodeSpec, NodeSpecRegistry, PortSpec, } from '../store/registry/defineNode';
-export { defineType } from '../store/registry/defineType';
-export type { TypeSpec } from '../store/registry/defineType';
-export type { NodePack, PackSetupContext } from '../store/registry';
-export type { GraphPortSpec, IndefiniteNode, NodeLocation, PortDefinition, PortTypeDefinition, TypeWidgetSpec, } from '../store/model';

package/dist/src/store/composite/editContext.d.ts

@@ -1,14 +0,0 @@
-import { DefiniteNode, NodeMap } from '../model';
-import { UpdateGraphInterfaceOptions } from '../interface/graphInterface';
-export interface EditFrame {
-    compositeNodeId: string;
-}
-export interface EditContext {
-    activeMap: NodeMap;
-    interfaceOptions?: UpdateGraphInterfaceOptions;
-}
-export declare function compositeAtDepth(root: NodeMap, stack: EditFrame[], depth: number): DefiniteNode | null;
-export declare function currentComposite(root: NodeMap, stack: EditFrame[]): DefiniteNode | null;
-export declare function resolveEditContext(root: NodeMap, stack: EditFrame[]): EditContext;
-export declare function compositeLabel(node: DefiniteNode): string;
-export declare function breadcrumbPath(root: NodeMap, stack: EditFrame[]): string[];

package/dist/src/store/composite/guards.d.ts

@@ -1,7 +0,0 @@
-import { DefiniteNode, NodeGraph, NodeMap } from '../model';
-import { EditFrame } from './editContext';
-export declare function graphContainsNodeId(graph: NodeGraph, id: string, deep: boolean): boolean;
-export declare function ancestorCompositeIds(stack: EditFrame[]): string[];
-export declare function validateCompositePlacement(root: NodeMap, stack: EditFrame[], targetGraph: NodeGraph): string | null;
-export declare function validateCompositeDrillIn(root: NodeMap, stack: EditFrame[], target: DefiniteNode): string | null;
-export declare function wouldCreateCompositeCycle(root: NodeMap, stack: EditFrame[], node: DefiniteNode, hostGraph: NodeGraph): string | null;

package/dist/src/store/composite/index.d.ts

@@ -1,12 +0,0 @@
-import { NodeSpec } from '../registry/defineNode';
-import { UpdateGraphInterfaceOptions } from '../interface/graphInterface';
-import { DefiniteNode, GraphInterface, NodeLocation, NodeMap } from '../model';
-export declare const COMPOSITE_TYPE = "composite/group";
-export type { UpdateGraphInterfaceOptions };
-export declare const compositeNode: NodeSpec;
-export declare function buildNestedMap(parent: NodeMap, composite: DefiniteNode): NodeMap;
-export declare function persistNestedMap(parent: NodeMap, composite: DefiniteNode, nested: NodeMap): void;
-export declare function reconcileCompositePorts(map: NodeMap, composite: DefiniteNode): void;
-export declare function applyGraphInterfaceUpdate(map: NodeMap, iface: GraphInterface, options?: UpdateGraphInterfaceOptions): string[];
-export declare function instantiateComposite(parent: NodeMap, location: NodeLocation): DefiniteNode;
-export declare function isCompositeNode(node: DefiniteNode): boolean;

package/dist/src/store/graph/connect.d.ts

@@ -1,8 +0,0 @@
-import { Connection, NodeId, NodeMap, PortRef, PortTypeId } from '../model';
-export declare function assignable(map: NodeMap, from: PortTypeId, to: PortTypeId): boolean;
-export declare function ancestorNodeIds(map: NodeMap, nodeId: NodeId): NodeId[];
-export declare function descendantNodeIds(map: NodeMap, nodeId: NodeId): NodeId[];
-export declare function wouldCreateCycle(map: NodeMap, from: PortRef, to: PortRef): boolean;
-export declare function canConnect(map: NodeMap, from: PortRef, to: PortRef): boolean;
-export declare function addConnection(map: NodeMap, from: PortRef, to: PortRef): Connection | null;
-export declare function removeConnection(map: NodeMap, id: string): void;

package/dist/src/store/graph/createNodeMap.d.ts

@@ -1,20 +0,0 @@
-import { GraphDocument, GraphInterface, NodeGraph, NodeMap, TypeRegistry } from '../model';
-import { NodePack } from '../registry';
-import { NodeSpecRegistry } from '../registry/defineNode';
-/** Options for the vue entry `createNodeMap()`. */
-export interface CreateNodeMapInit {
-    /** Initial graph contents. Defaults to empty nodes and connections. */
-    graph?: NodeGraph;
-    /** Pre-loaded pack ids (usually leave empty and use {@link NodeMap.loadPack}). */
-    extensions?: string[];
-    /** Graph boundary ports; defaults to no inputs and no outputs. */
-    graphInterface?: GraphInterface;
-    /** Extra types to merge into the registry at creation time. */
-    types?: TypeRegistry;
-    /** Extra node types to merge into the registry at creation time (authoring form). */
-    nodeTypes?: NodeSpecRegistry;
-    /** Packs to load immediately after creation (via {@link NodeMap.loadPack}). */
-    packs?: NodePack[];
-}
-export declare function createNodeMapBase(init?: CreateNodeMapInit): NodeMap;
-export type { GraphDocument };

package/dist/src/store/graph/document.d.ts

@@ -1,25 +0,0 @@
-import { GraphDocument, NodeMap } from '../model';
-/**
- * Serialize the current workspace to a {@link GraphDocument}.
- * Alias of {@link exportGraph}.
- */
-export declare function serializeDocument(map: NodeMap): GraphDocument;
-/** Serialize the current workspace to a {@link GraphDocument}. */
-export declare function exportGraph(map: NodeMap): GraphDocument;
-/**
- * Parse a JSON string into a {@link GraphDocument}.
- * @throws When JSON is invalid or required fields are missing.
- */
-export declare function parseGraphDocument(json: string): GraphDocument;
-/**
- * Validate a document against the current map without applying it.
- * @returns Human-readable error messages (empty when valid).
- */
-export declare function validateDocument(map: NodeMap, doc: GraphDocument): string[];
-/**
- * Replace the map's graph and interface from a document.
- * @returns Errors from extension checks before apply, then validation errors after apply.
- */
-export declare function applyDocument(map: NodeMap, doc: GraphDocument): string[];
-/** Replace the map's graph from a document. Alias of {@link applyDocument}. */
-export declare function importGraph(map: NodeMap, doc: GraphDocument): string[];

package/dist/src/store/graph/dynamicPorts.d.ts

@@ -1,9 +0,0 @@
-import { DefiniteNode, IndefiniteNode, NodeIO, NodeIODefinition, NodeMap, PortDirection } from '../model';
-export declare function resolveNodePorts(def: IndefiniteNode, params: Record<string, unknown>): {
-    inputs: NodeIODefinition;
-    outputs: NodeIODefinition;
-};
-export declare function nodeParams(node: DefiniteNode): Record<string, unknown>;
-export declare function defaultParams(def: IndefiniteNode): Record<string, unknown>;
-export declare function reconcileSide(old: NodeIO, defs: NodeIODefinition, direction: PortDirection): NodeIO;
-export declare function reconcilePorts(map: NodeMap, node: DefiniteNode): void;

package/dist/src/store/graph/evaluate.d.ts

@@ -1,18 +0,0 @@
-import { NodeId, NodeMap } from '../model';
-/** Port values keyed by port name. */
-export type Values = Record<string, unknown>;
-/** Evaluation errors keyed by {@link NodeId}. */
-export type NodeErrors = Record<NodeId, string>;
-export interface GraphRunResult {
-    /** Output port values from the graph's Output node, keyed by port name. */
-    values: Values;
-    /** First error per node encountered during evaluation. */
-    errors: NodeErrors;
-}
-/**
- * Evaluate the graph as a function: supply values for the Input node's output
- * ports (keyed by port name) and receive the Output node's input port values.
- *
- * Uses pull-based recursive evaluation with per-node memoization and cycle detection.
- */
-export declare function runGraph(map: NodeMap, inputs?: Values): GraphRunResult;

package/dist/src/store/graph/expandIO.d.ts

@@ -1,2 +0,0 @@
-import { GraphPortSpec, NodeIODefinition } from '../model';
-export declare function expandIO(spec: Record<string, GraphPortSpec> | undefined): NodeIODefinition;

package/dist/src/store/graph/instance.d.ts

@@ -1,7 +0,0 @@
-import { DefiniteNode, IndefiniteNode, NodeLocation } from '../model';
-/**
- * Create a placed {@link DefiniteNode} from a node type, generating fresh port ids.
- * For dynamic nodes, the initial port set comes from {@link IndefiniteNode.resolvePorts}
- * seeded with the definition's default parameter values.
- */
-export declare function instantiate(def: IndefiniteNode, location: NodeLocation): DefiniteNode;

package/dist/src/store/graph/pruneConnections.d.ts

@@ -1,2 +0,0 @@
-import { DefiniteNode, NodeMap } from '../model';
-export declare function pruneConnectionsForNode(map: NodeMap, node: DefiniteNode): void;

package/dist/src/store/graph/removeNode.d.ts

@@ -1,3 +0,0 @@
-import { NodeId, NodeMap } from '../model';
-export declare function canRemoveNode(map: NodeMap, id: NodeId): boolean;
-export declare function removeNode(map: NodeMap, id: NodeId): void;

package/dist/src/store/graph/stacking.d.ts

@@ -1,5 +0,0 @@
-import { NodeId, NodeMap } from '../model';
-export declare function topZ(map: NodeMap): number;
-export declare function normalizeStackingOrder(map: NodeMap): void;
-export declare function ensureStackingOrder(map: NodeMap): void;
-export declare function bringToFront(map: NodeMap, id: NodeId): void;

package/dist/src/store/graph/validateGraphTypes.d.ts

@@ -1,2 +0,0 @@
-import { NodeGraph, NodeMap } from '../model';
-export declare function validateGraphTypes(map: NodeMap, graph: NodeGraph, errors?: string[]): string[];

package/dist/src/store/interface/editor.d.ts

@@ -1,5 +0,0 @@
-import { GraphInterface, NodeMap } from '../model';
-import { EditFrame } from '../composite/editContext';
-export type InterfaceMutator = (iface: GraphInterface) => void;
-export declare function canonicalGraphInterface(root: NodeMap, stack: EditFrame[]): GraphInterface;
-export declare function applyInterfaceMutation(root: NodeMap, stack: EditFrame[], mutate: InterfaceMutator): string[];

package/dist/src/store/interface/graphInterface.d.ts

@@ -1,20 +0,0 @@
-import { DefiniteNode, GraphInterface, GraphPortSpec, NodeMap } from '../model';
-import { expandIO } from '../graph/expandIO';
-export declare const PORT_NAME_RE: RegExp;
-export declare function validateGraphInterface(map: NodeMap, iface: GraphInterface): string[];
-export declare function cloneGraphInterface(iface: GraphInterface): GraphInterface;
-export declare function uniquePortName(existing: Record<string, GraphPortSpec> | undefined, base?: string): string;
-export declare function addParameter(iface: GraphInterface, name?: string): GraphInterface;
-export declare function addReturn(iface: GraphInterface, name?: string): GraphInterface;
-export declare function removeParameter(iface: GraphInterface, name: string): GraphInterface;
-export declare function removeReturn(iface: GraphInterface, name: string): GraphInterface;
-export declare function renameParameter(iface: GraphInterface, oldName: string, newName: string): GraphInterface;
-export declare function renameReturn(iface: GraphInterface, oldName: string, newName: string): GraphInterface;
-export declare function setParameterSpec(iface: GraphInterface, name: string, spec: GraphPortSpec): GraphInterface;
-export declare function setReturnSpec(iface: GraphInterface, name: string, spec: GraphPortSpec): GraphInterface;
-export interface UpdateGraphInterfaceOptions {
-    /** When editing a nested graph, sync ports on the parent composite instance. */
-    ownerComposite?: DefiniteNode;
-    parentMap?: NodeMap;
-}
-export { expandIO };

package/dist/src/store/model.d.ts

@@ -1,241 +0,0 @@
-import { NodePack } from './registry';
-export type NodeId = string;
-export type PortId = string;
-export type ConnectionId = string;
-export type NodeTypeId = string;
-export type NodeLocation = {
-    x: number;
-    y: number;
-};
-/** Key into the {@link TypeRegistry} (e.g. `"number"`). */
-export type PortTypeId = string;
-export type PortType = PortTypeId;
-/**
- * Serializable widget descriptor for port value editing and display. Lives on the
- * type definition; the Vue viewer resolves it to a concrete component.
- */
-export type TypeWidgetSpec = {
-    kind: "number";
-    min?: number;
-    max?: number;
-    step?: number;
-    /** Port row height in px; defaults to one line (20px). */
-    rowHeight?: number;
-} | {
-    kind: "text";
-    /** Multiline row count; height is `rows × 20px` unless `rowHeight` is set. */
-    rows?: number;
-    /** Port row height in px; overrides `rows`. */
-    rowHeight?: number;
-} | {
-    kind: "custom";
-    /** Id passed to `registerComponentWidget` in a pack's `setup` hook. */
-    componentId: string;
-    /** Port row height in px; defaults to one line (20px). */
-    rowHeight?: number;
-};
-/**
- * A registered data type. Carries validation, connection compatibility, and
- * optional value lifecycle hooks. Registered at startup — only {@link PortTypeId}
- * keys on ports are serialized in documents.
- */
-export interface PortTypeDefinition {
-    id: PortTypeId;
-    label: string;
-    color: string;
-    validate: (value: unknown) => boolean;
-    /**
-     * Whether an output of type `from` may connect into an input of this type.
-     * Decided by the destination type. Omitted means strict identity (`from === id`).
-     */
-    accepts?: (from: PortTypeId) => boolean;
-    /** Fallback when a port of this type omits its own default. */
-    defaultValue?: unknown;
-    /** Display/edit descriptor for the viewer (no functions). */
-    widget?: TypeWidgetSpec;
-    /** Parse a raw string (e.g. from an input field) into a value. */
-    parse?: (raw: string) => unknown;
-    /** Format a value for display in the viewer. */
-    format?: (value: unknown) => string;
-    /** Normalize or clamp a value after edit or connection. */
-    coerce?: (value: unknown) => unknown;
-}
-/** Library of available data types, keyed by id. */
-export type TypeRegistry = Record<PortTypeId, PortTypeDefinition>;
-export type PortDirection = "input" | "output";
-/**
- * Port template declared by a node type ({@link IndefiniteNode}). Has no id and
- * no live value — only describes ports that instances will receive.
- */
-export type PortDefinition = {
-    /** Stable, human-authored key; referenced inside `execute()`. */
-    name: string;
-    type: PortType;
-    /** Used by an input when nothing is connected to it. */
-    defaultValue?: unknown;
-    description?: string;
-    /**
-     * Input-only. Never accepts a connection — no socket, always shows its widget.
-     * Also feeds parameters into {@link IndefiniteNode.resolvePorts}.
-     */
-    userOnly?: boolean;
-    /**
-     * Input-only. Accepts any number of incoming connections; `execute()` receives
-     * values as an unordered array of `type`.
-     */
-    multi?: boolean;
-    /**
-     * Widget-specific configuration merged on top of the type's widget spec.
-     * Recognized keys: `options`, `min`, `max`, `step`, `rows`, `rowHeight`.
-     */
-    customProps?: Record<string, unknown>;
-};
-/**
- * Materialized port on a placed node ({@link DefiniteNode}). Has a unique id so
- * connections and the DOM can reference it directly.
- */
-export type Port = {
-    id: PortId;
-    /** Matches the {@link PortDefinition.name} it came from. */
-    name: string;
-    type: PortType;
-    direction: PortDirection;
-    /** Input: value when disconnected. Output: optional cache of last computed value. */
-    value?: unknown;
-    userOnly?: boolean;
-    multi?: boolean;
-    customProps?: Record<string, unknown>;
-};
-/** Port templates on a definition, keyed by name (authoring-friendly). */
-export type NodeIODefinition = Record<string, PortDefinition>;
-/** Materialized ports on an instance, keyed by id (connection/DOM-friendly). */
-export type NodeIO = Record<PortId, Port>;
-/** Reference to one port on one node. */
-export type PortRef = {
-    node: NodeId;
-    port: PortId;
-};
-/**
- * Node type template that {@link DefiniteNode} instances are created from. Lives
- * in the runtime registry only (never in a saved graph). Authors ship types via
- * {@link NodePack}.
- *
- * - **Primitive:** implements {@link IndefiniteNode.execute}.
- * - **Composite:** supplies a nested {@link IndefiniteNode.graph} instead of `execute`.
- */
-export interface IndefiniteNode {
-    /** Unique node type id (e.g. `"my-pack/add"`). */
-    typeId: NodeTypeId;
-    displayName: string;
-    color: string;
-    description: string;
-    /**
-     * Hierarchical menu category, broadest first, e.g. `["Math", "Basic Operations"]`.
-     * Empty or omitted places the node at the menu root.
-     */
-    group?: string[];
-    inputs: NodeIODefinition;
-    outputs: NodeIODefinition;
-    /**
-     * Runtime evaluation, keyed by port name (not id). Omit for composite types.
-     * @returns Output values keyed by port name.
-     */
-    execute?: (inputs: Record<string, unknown>) => Record<string, unknown>;
-    /** Nested subgraph for composite types (registry-only, not evaluated standalone). */
-    graph?: NodeGraph;
-    /**
-     * Dynamic port count driven by user-only inputs. When present, static
-     * `inputs`/`outputs` are initial defaults; reconciliation re-materializes
-     * ports by name so existing ids and connections survive a recount.
-     */
-    resolvePorts?: (params: Record<string, unknown>) => {
-        inputs: NodeIODefinition;
-        outputs: NodeIODefinition;
-    };
-}
-/**
- * A node placed on the workspace. Serializable data only — behaviour lives on
- * the {@link IndefiniteNode} referenced by {@link DefiniteNode.typeId}.
- */
-export interface DefiniteNode {
-    id: NodeId;
-    /** {@link IndefiniteNode} this instance was created from. */
-    typeId: NodeTypeId;
-    location: NodeLocation;
-    inputs: NodeIO;
-    outputs: NodeIO;
-    label?: string;
-    color?: string;
-    /** Node width in px. Falls back to layout default when undefined. */
-    width?: number;
-    /**
-     * Stacking order — higher paints on top. Stored for save/load. Undefined until
-     * first assigned.
-     */
-    z?: number;
-    /** Nested graph for composite/group instances. Serializable with the node. */
-    composite?: CompositeState;
-}
-/** Serializable nested graph owned by a composite instance. */
-export interface CompositeState {
-    graph: NodeGraph;
-    interface: GraphInterface;
-}
-/**
- * Directed wire from an output port to an input port. Stored centrally on the
- * graph so either endpoint can be looked up uniformly.
- */
-export interface Connection {
-    id: ConnectionId;
-    /** Must reference an output port. */
-    from: PortRef;
-    /** Must reference an input port. */
-    to: PortRef;
-}
-/** Serializable port template for boundary definitions (object key = port name). */
-export type GraphPortSpec = Omit<PortDefinition, "name">;
-/**
- * External signature of a graph. Parameters become the Input node's output ports;
- * returns become the Output node's input ports.
- */
-export interface GraphInterface {
-    /** Graph inputs (function parameters). Key = port name. */
-    parameters?: Record<string, GraphPortSpec>;
-    /** Graph outputs (return values). Key = port name. */
-    returns?: Record<string, GraphPortSpec>;
-}
-export declare const defaultGraphInterface: GraphInterface;
-/**
- * Placed nodes and connections. Every graph must contain exactly one Input node
- * and one Output node.
- */
-export interface NodeGraph {
-    nodes: DefiniteNode[];
-    connections: Connection[];
-}
-/**
- * Serializable graph snapshot. Contains no `execute()` implementations or type
- * definitions — custom nodes are resolved at runtime from loaded {@link NodePack}s.
- */
-export interface GraphDocument {
-    graph: NodeGraph;
-    interface: GraphInterface;
-    /** Pack ids required to interpret this document. See {@link NodeMap.extensions}. */
-    extensions?: string[];
-}
-/** Library of available node types, keyed by {@link NodeTypeId}. */
-export type NodeRegistry = Record<NodeTypeId, IndefiniteNode>;
-/** In-memory workspace: serializable graph plus runtime type and node registries. */
-export interface NodeMap {
-    graph: NodeGraph;
-    types: TypeRegistry;
-    nodeTypes: NodeRegistry;
-    /** Ids of packs loaded via {@link NodeMap.loadPack}. */
-    extensions: string[];
-    graphInterface: GraphInterface;
-    /**
-     * Register types, nodes, and optional widget setup from a pack.
-     * @returns Registration errors (empty array on success).
-     */
-    loadPack(pack: NodePack): string[];
-}

package/dist/src/store/nodes/io.d.ts

@@ -1,46 +0,0 @@
-import { NodeSpec } from '../registry/defineNode';
-import { DefiniteNode, GraphInterface, NodeMap } from '../model';
-/** {@link IndefiniteNode.typeId} for the graph Input (Group Input) boundary node. */
-export declare const INPUT_TYPE = "io/input";
-/** {@link IndefiniteNode.typeId} for the graph Output (Group Output) boundary node. */
-export declare const OUTPUT_TYPE = "io/output";
-export declare const DEFAULT_BOUNDARY_LAYOUT: {
-    input: {
-        x: number;
-        y: number;
-    };
-    output: {
-        x: number;
-        y: number;
-    };
-};
-export type { GraphInterface } from '../model';
-export { defaultGraphInterface as defaultInterface } from '../model';
-export declare function createIONodes(iface?: GraphInterface): {
-    input: NodeSpec;
-    output: NodeSpec;
-};
-export declare function applyGraphInterface(map: NodeMap, iface: GraphInterface): void;
-/**
- * Return the single Input and Output nodes on the graph.
- * @throws When the graph does not contain exactly one of each.
- */
-export declare function boundaryNodes(map: NodeMap): {
-    input: DefiniteNode;
-    output: DefiniteNode;
-};
-export declare function ensureBoundaryNodes(map: NodeMap, layout?: {
-    input: {
-        x: number;
-        y: number;
-    };
-    output: {
-        x: number;
-        y: number;
-    };
-}): {
-    input: DefiniteNode;
-    output: DefiniteNode;
-};
-export declare function updateGraphInterface(map: NodeMap, iface: GraphInterface): string[];
-export declare function validateBoundary(map: NodeMap): string[];

package/dist/src/store/packs/installPack.d.ts

@@ -1,4 +0,0 @@
-import { NodeMap } from '../model';
-import { NodePack, PackSetupContext } from '../registry';
-export type { NodePack, PackSetupContext } from '../registry';
-export declare function installPack(map: NodeMap, pack: NodePack, setupCtx?: PackSetupContext): string[];

package/dist/src/store/registry/defineNode.d.ts

@@ -1,50 +0,0 @@
-import { GraphPortSpec, IndefiniteNode, NodeGraph, NodeTypeId } from '../model';
-/**
- * Port in a node spec — same as {@link GraphPortSpec}; the name comes from the
- * object key so authors do not repeat it.
- */
-export type PortSpec = GraphPortSpec;
-/** Input or output port templates keyed by port name. */
-export type IOSpec = Record<string, PortSpec>;
-/**
- * Authoring form of {@link IndefiniteNode.resolvePorts}. Returns ports in
- * {@link IOSpec} shape; normalized when registered via {@link registerNodeTypes}.
- */
-export type DynamicPortsSpec = (params: Record<string, unknown>) => {
-    inputs?: IOSpec;
-    outputs?: IOSpec;
-};
-/**
- * Authoring format for a node type. Normalized into a full {@link IndefiniteNode}
- * when registered on a {@link NodeMap} (via {@link NodePack} or
- * {@link registerNodeTypes}).
- */
-export interface NodeSpec {
-    /** Unique node type id (e.g. `"my-pack/add"`). */
-    typeId: NodeTypeId;
-    displayName: string;
-    color?: string;
-    description?: string;
-    /**
-     * Hierarchical menu category, broadest first. See {@link IndefiniteNode.group}.
-     */
-    group?: string[];
-    inputs?: IOSpec;
-    outputs?: IOSpec;
-    /**
-     * Runtime evaluation, keyed by port name. Omit for composite node packs.
-     * @returns Output values keyed by port name.
-     */
-    execute?: (inputs: Record<string, unknown>) => Record<string, unknown>;
-    /** Nested subgraph for composite types in a published pack. Not evaluated yet. */
-    graph?: NodeGraph;
-    /**
-     * Dynamic port count driven by user-only inputs. Static `inputs`/`outputs`
-     * act as initial defaults when present.
-     */
-    resolvePorts?: DynamicPortsSpec;
-}
-/** Node types in authoring form, keyed by {@link NodeTypeId}. */
-export type NodeSpecRegistry = Record<NodeTypeId, NodeSpec>;
-/** Expand a {@link NodeSpec} into a runtime {@link IndefiniteNode}. */
-export declare function normalizeNode(spec: NodeSpec): IndefiniteNode;