@nodish/core 0.1.3 → 0.2.0

package/dist/{vue.js → index.js}

@@ -1,5 +1,5 @@
 import { Fragment as e, computed as t, createBlock as n, createCommentVNode as r, createElementBlock as i, createElementVNode as a, createVNode as o, defineComponent as s, nextTick as c, normalizeClass as l, normalizeStyle as u, onMounted as d, onUnmounted as f, openBlock as p, ref as m, renderList as h, renderSlot as g, resolveDynamicComponent as _, toDisplayString as v, unref as y, useCssVars as b, vModelText as x, watch as ee, withCtx as S, withDirectives as C, withModifiers as w } from "vue";
-import './vue.css';//#region src/store/graph/pruneConnections.ts
+import './index.css';//#region src/store/graph/pruneConnections.ts
 function T(e, t) {
 	e.graph.connections = e.graph.connections.filter((e) => !(e.from.node === t.id && !t.outputs[e.from.port] || e.to.node === t.id && !t.inputs[e.to.port]));
 }
@@ -63,17 +63,8 @@ function j(e) {
 //#endregion
 //#region src/store/model.ts
 var M = {
-	parameters: {
-		a: {
-			type: "number",
-			defaultValue: 0
-		},
-		b: {
-			type: "number",
-			defaultValue: 0
-		}
-	},
-	returns: { result: { type: "number" } }
+	parameters: {},
+	returns: {}
 };
 //#endregion
 //#region src/store/registry/defineNode.ts
@@ -2247,139 +2238,8 @@ function In() {
 	Je("number", Q), Je("string", $);
 }
 //#endregion
-//#region src/store/nodes/math.ts
-var Ln = {
-	typeId: "math/add",
-	displayName: "Add",
-	color: "#4a7a4a",
-	description: "Add two numbers",
-	group: ["math", "basic operations"],
-	inputs: {
-		a: {
-			type: "number",
-			defaultValue: 0
-		},
-		b: {
-			type: "number",
-			defaultValue: 0
-		}
-	},
-	outputs: { sum: { type: "number" } },
-	execute: (e) => ({ sum: Number(e.a ?? 0) + Number(e.b ?? 0) })
-}, Rn = {
-	typeId: "math/multiply",
-	displayName: "Multiply",
-	color: "#4a7a4a",
-	description: "Multiply two numbers",
-	group: ["math", "basic operations"],
-	inputs: {
-		a: {
-			type: "number",
-			defaultValue: 0
-		},
-		b: {
-			type: "number",
-			defaultValue: 0
-		}
-	},
-	outputs: { product: { type: "number" } },
-	execute: (e) => ({ product: Number(e.a ?? 0) * Number(e.b ?? 0) })
-}, zn = {
-	typeId: "math/divide",
-	displayName: "Divide",
-	color: "#4a7a4a",
-	description: "Divide two numbers",
-	group: ["math", "basic operations"],
-	inputs: {
-		a: {
-			type: "number",
-			defaultValue: 0
-		},
-		b: {
-			type: "number",
-			defaultValue: 1
-		}
-	},
-	outputs: { quotient: { type: "number" } },
-	execute: (e) => {
-		let t = Number(e.a ?? 0), n = Number(e.b ?? 1);
-		if (n === 0) throw Error("Division by zero");
-		return { quotient: t / n };
-	}
-}, Bn = {
-	[Ln.typeId]: Ln,
-	[Rn.typeId]: Rn,
-	[zn.typeId]: zn
-};
-//#endregion
-//#region src/store/registry/defineType.ts
-function Vn(e) {
-	let t = e.widget, n = Wn(t);
-	return {
-		id: e.id,
-		label: e.label ?? Hn(e.id),
-		color: e.color ?? "#888",
-		validate: e.validate,
-		accepts: e.accepts,
-		defaultValue: e.defaultValue,
-		widget: t,
-		parse: e.parse ?? n.parse,
-		format: e.format ?? n.format,
-		coerce: e.coerce ?? n.coerce
-	};
-}
-function Hn(e) {
-	return e.charAt(0).toUpperCase() + e.slice(1);
-}
-function Un(e, t, n) {
-	let r = Number(e);
-	return Number.isNaN(r) && (r = 0), t !== void 0 && (r = Math.max(t, r)), n !== void 0 && (r = Math.min(n, r)), r;
-}
-function Wn(e) {
-	if (!e) return {
-		parse: (e) => e,
-		format: (e) => e == null ? "" : String(e)
-	};
-	switch (e.kind) {
-		case "number": return {
-			parse: (e) => Number(e),
-			format: (e) => e == null ? "" : String(e),
-			coerce: (t) => Un(t, e.min, e.max)
-		};
-		case "text": return {
-			parse: (e) => e,
-			format: (e) => e == null ? "" : String(e)
-		};
-		case "custom": return { format: (e) => e == null ? "" : String(e) };
-	}
-}
-//#endregion
-//#region src/store/types/index.ts
-var Gn = Vn({
-	id: "number",
-	label: "Number",
-	color: "#7dd3fc",
-	validate: (e) => typeof e == "number" && !Number.isNaN(e),
-	defaultValue: 0,
-	widget: { kind: "number" }
-}), Kn = Vn({
-	id: "string",
-	label: "String",
-	color: "#c4b5fd",
-	validate: (e) => typeof e == "string",
-	defaultValue: "",
-	widget: { kind: "text" }
-}), qn = {
-	id: "@local/core",
-	types: {
-		[Gn.id]: Gn,
-		[Kn.id]: Kn
-	},
-	nodeTypes: Bn
-};
-//#endregion
 //#region src/store/graph/createNodeMap.ts
-function Jn(e = {}) {
+function Ln(e = {}) {
 	let t = {
 		graph: e.graph ?? {
 			nodes: [],
@@ -2395,7 +2255,7 @@ function Jn(e = {}) {
 }
 //#endregion
 //#region src/store/packs/installPack.ts
-function Yn(e, t, n) {
+function Rn(e, t, n) {
 	if (e.extensions.includes(t.id)) return [];
 	let r = [];
 	if (t.types) for (let n of Object.keys(t.types)) e.types[n] && r.push(`type "${n}" already registered by another pack`);
@@ -2404,53 +2264,53 @@ function Yn(e, t, n) {
 }
 //#endregion
 //#region src/vue/attachLoadPack.ts
-function Xn() {
+function zn() {
 	return {
 		registerTypeWidget: Je,
 		registerComponentWidget: Ye
 	};
 }
-function Zn(e) {
-	e.loadPack = (t) => Yn(e, t, Xn());
+function Bn(e) {
+	e.loadPack = (t) => Rn(e, t, zn());
 }
 //#endregion
 //#region src/vue/createNodeMap.ts
-var Qn = !1;
-function $n(e = {}) {
-	Qn ||= (In(), !0);
-	let t = Jn(e);
-	Zn(t), e.defaultPack !== !1 && t.loadPack(qn);
+var Vn = !1;
+function Hn(e = {}) {
+	Vn ||= (In(), !0);
+	let t = Ln(e);
+	Bn(t);
 	for (let n of e.packs ?? []) t.loadPack(n);
 	return t;
 }
 //#endregion
 //#region src/store/graph/validateGraphTypes.ts
-function er(e, t, n, r, i) {
+function Un(e, t, n, r, i) {
 	e.types[n.type] || i.push(`node "${t.label ?? t.typeId}" (${t.id}): unknown ${r} port type "${n.type}" on port "${n.name}"`);
 }
-function tr(e, t, n) {
+function Wn(e, t, n) {
 	e.nodeTypes[t.typeId] || n.push(`node "${t.label ?? t.id}": unknown typeId "${t.typeId}"`);
-	for (let r of Object.values(t.inputs)) er(e, t, r, "input", n);
-	for (let r of Object.values(t.outputs)) er(e, t, r, "output", n);
-	t.composite?.graph && nr(e, t.composite.graph, n);
+	for (let r of Object.values(t.inputs)) Un(e, t, r, "input", n);
+	for (let r of Object.values(t.outputs)) Un(e, t, r, "output", n);
+	t.composite?.graph && Gn(e, t.composite.graph, n);
 }
-function nr(e, t, n = []) {
-	for (let r of t.nodes) tr(e, r, n);
+function Gn(e, t, n = []) {
+	for (let r of t.nodes) Wn(e, r, n);
 	return n;
 }
 //#endregion
 //#region src/store/graph/document.ts
-function rr(e) {
+function Kn(e) {
 	return {
 		graph: z(e.graph),
 		interface: z(e.graphInterface),
 		extensions: e.extensions.length ? [...e.extensions] : void 0
 	};
 }
-function ir(e) {
-	return rr(e);
+function qn(e) {
+	return Kn(e);
 }
-function ar(e) {
+function Jn(e) {
 	let t;
 	try {
 		t = JSON.parse(e);
@@ -2466,22 +2326,64 @@ function ar(e) {
 	if (n.extensions !== void 0 && (!Array.isArray(n.extensions) || n.extensions.some((e) => typeof e != "string"))) throw Error("extensions must be an array of strings");
 	return n;
 }
-function or(e, t) {
+function Yn(e, t) {
 	return t?.length ? t.filter((t) => !e.extensions.includes(t)).map((e) => `missing pack "${e}" (call map.loadPack() before import)`) : [];
 }
-function sr(e, t) {
+function Xn(e, t) {
 	let n = [];
-	return n.push(...or(e, t.extensions)), n.push(...se({
+	return n.push(...Yn(e, t.extensions)), n.push(...se({
 		...e,
 		graph: t.graph
-	})), n.push(...B(e, t.interface)), n.push(...nr(e, t.graph)), n;
+	})), n.push(...B(e, t.interface)), n.push(...Gn(e, t.graph)), n;
 }
-function cr(e, t) {
-	let n = or(e, t.extensions);
-	return n.length ? n : (e.graph = z(t.graph), e.graphInterface = z(t.interface), ie(e, e.graphInterface), oe(e), n.push(...sr(e, t)), n);
+function Zn(e, t) {
+	let n = Yn(e, t.extensions);
+	return n.length ? n : (e.graph = z(t.graph), e.graphInterface = z(t.interface), ie(e, e.graphInterface), oe(e), n.push(...Xn(e, t)), n);
 }
-function lr(e, t) {
-	return cr(e, t);
+function Qn(e, t) {
+	return Zn(e, t);
+}
+//#endregion
+//#region src/store/registry/defineType.ts
+function $n(e) {
+	let t = e.widget, n = nr(t);
+	return {
+		id: e.id,
+		label: e.label ?? er(e.id),
+		color: e.color ?? "#888",
+		validate: e.validate,
+		accepts: e.accepts,
+		defaultValue: e.defaultValue,
+		widget: t,
+		parse: e.parse ?? n.parse,
+		format: e.format ?? n.format,
+		coerce: e.coerce ?? n.coerce
+	};
+}
+function er(e) {
+	return e.charAt(0).toUpperCase() + e.slice(1);
+}
+function tr(e, t, n) {
+	let r = Number(e);
+	return Number.isNaN(r) && (r = 0), t !== void 0 && (r = Math.max(t, r)), n !== void 0 && (r = Math.min(n, r)), r;
+}
+function nr(e) {
+	if (!e) return {
+		parse: (e) => e,
+		format: (e) => e == null ? "" : String(e)
+	};
+	switch (e.kind) {
+		case "number": return {
+			parse: (e) => Number(e),
+			format: (e) => e == null ? "" : String(e),
+			coerce: (t) => tr(t, e.min, e.max)
+		};
+		case "text": return {
+			parse: (e) => e,
+			format: (e) => e == null ? "" : String(e)
+		};
+		case "custom": return { format: (e) => e == null ? "" : String(e) };
+	}
 }
 //#endregion
-export { V as INPUT_TYPE, Fn as NodeViewer, H as OUTPUT_TYPE, cr as applyDocument, ae as boundaryNodes, $n as createNodeMap, Vn as defineType, ir as exportGraph, lr as importGraph, R as instantiate, ar as parseGraphDocument, Ye as registerComponentWidget, In as registerDefaultTypeWidgets, Je as registerTypeWidget, he as runGraph, rr as serializeDocument, sr as validateDocument };
+export { V as INPUT_TYPE, Fn as NodeViewer, H as OUTPUT_TYPE, Zn as applyDocument, ae as boundaryNodes, Hn as createNodeMap, $n as defineType, qn as exportGraph, Qn as importGraph, R as instantiate, Jn as parseGraphDocument, Ye as registerComponentWidget, In as registerDefaultTypeWidgets, Je as registerTypeWidget, he as runGraph, Kn as serializeDocument, Xn as validateDocument };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nodish/core",
   "private": false,
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "sideEffects": [
     "**/*.css"
@@ -9,22 +9,20 @@
   "files": [
     "dist"
   ],
+  "types": "./dist/index.d.ts",
   "exports": {
-    "./pack": {
-      "types": "./dist/pack.d.ts",
-      "import": "./dist/pack.js"
-    },
-    "./vue": {
-      "types": "./dist/src/vue/index.d.ts",
-      "import": "./dist/vue.js",
-      "style": "./dist/vue.css"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "style": "./dist/index.css"
     }
   },
   "scripts": {
     "setup:local": "node scripts/copy-dev-to-local.mjs",
     "dev": "node scripts/copy-dev-to-local.mjs && vite --config vite.config.dev.ts",
-    "build": "vite build --config vite.config.pack.ts && vite build --config vite.config.vue.ts && dts-bundle-generator --export-referenced-types --no-check -o dist/pack.d.ts src/pack/index.ts",
-    "typecheck": "tsc --noEmit"
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "typecheck:dev": "tsc --noEmit -p tsconfig.dev.json"
   },
   "peerDependencies": {
     "vue": "^3.5.0"
@@ -32,7 +30,6 @@
   "devDependencies": {
     "@types/node": "^26.0.1",
     "@vitejs/plugin-vue": "^6.0.7",
-    "dts-bundle-generator": "^9.5.1",
     "typescript": "~6.0.2",
     "vite": "^8.0.12",
     "vite-plugin-dts": "^4.5.4",

package/dist/pack.d.ts

@@ -1,326 +0,0 @@
-// Generated by dts-bundle-generator v9.5.1
-
-import { Component } from 'vue';
-
-/**
- * A publishable bundle of custom types and/or node types (npm package contents).
- * Load onto a {@link NodeMap} with {@link NodeMap.loadPack}.
- */
-export interface NodePack {
-	/** Unique pack id (e.g. `"@my-org/my-pack"`). Recorded in {@link GraphDocument.extensions}. */
-	id: string;
-	/** Custom {@link PortTypeDefinition}s to register. */
-	types?: TypeRegistry;
-	/** Custom node definitions to register (authoring form). */
-	nodeTypes?: NodeSpecRegistry;
-	/**
-	 * Optional hook to register Vue widgets after types and nodes are merged.
-	 * Runs once per pack load.
-	 */
-	setup?: (ctx: PackSetupContext) => void;
-}
-/** Context passed to {@link NodePack.setup} for widget registration. */
-export interface PackSetupContext {
-	/**
-	 * Bind a Vue component to all editable ports of a type id.
-	 * Overrides the generic widget for that type.
-	 */
-	registerTypeWidget: (typeId: string, component: Component) => void;
-	/**
-	 * Bind a Vue component to a custom widget id
-	 * ({@link TypeWidgetSpec} `kind: "custom"`).
-	 */
-	registerComponentWidget: (componentId: string, component: Component) => void;
-}
-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>;
-}
-/**
- * Placed nodes and connections. Every graph must contain exactly one Input node
- * and one Output node.
- */
-export interface NodeGraph {
-	nodes: DefiniteNode[];
-	connections: Connection[];
-}
-/**
- * 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>;
-/**
- * Authoring format for a data type. {@link defineType} expands this into a full
- * {@link PortTypeDefinition} (default label, color, and widget lifecycle hooks).
- */
-export interface TypeSpec {
-	/** Unique type id (e.g. `"number"`, `"my-pack/label"`). */
-	id: PortTypeId;
-	label?: string;
-	color?: string;
-	validate: (value: unknown) => boolean;
-	/**
-	 * Whether an output of type `from` may connect into ports of this type.
-	 * Omitted means strict identity.
-	 */
-	accepts?: (from: PortTypeId) => boolean;
-	/** Fallback when a port of this type omits its own default. */
-	defaultValue?: unknown;
-	/** Viewer widget descriptor for ports of this type. */
-	widget?: TypeWidgetSpec;
-	/** Override default parse behaviour for this type's widget. */
-	parse?: (raw: string) => unknown;
-	/** Override default format behaviour for this type's widget. */
-	format?: (value: unknown) => string;
-	/** Override default coerce behaviour for this type's widget. */
-	coerce?: (value: unknown) => unknown;
-}
-/**
- * Turn a {@link TypeSpec} into a complete {@link PortTypeDefinition}.
- */
-export declare function defineType(spec: TypeSpec): PortTypeDefinition;
-
-export {};