@ultrst-armada/kloks 1.0.2 → 1.1.0

package/index.d.ts

@@ -3,3 +3,4 @@ export * from './packages/state-graph/dist/index.d.ts';
 export * from './packages/audio-midi/dist/index.d.ts';
 export * from './packages/services/dist/index.d.ts';
 export * from './packages/orchestrations/dist/index.d.ts';
+export * from './packages/contracts/dist/index.d.ts';

package/index.js

@@ -3,3 +3,4 @@ export * from './packages/state-graph/dist/index.js';
 export * from './packages/audio-midi/dist/index.js';
 export * from './packages/services/dist/index.js';
 export * from './packages/orchestrations/dist/index.js';
+export * from './packages/contracts/dist/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -88,6 +88,11 @@
       "types": "./packages/orchestrations/dist/index.d.ts",
       "import": "./packages/orchestrations/dist/index.js",
       "default": "./packages/orchestrations/dist/index.js"
+    },
+    "./contracts": {
+      "types": "./packages/contracts/dist/index.d.ts",
+      "import": "./packages/contracts/dist/index.js",
+      "default": "./packages/contracts/dist/index.js"
     }
   },
   "scripts": {

package/packages/backend/dist/index.js

@@ -1,3 +1,11 @@
+import {
+  CompositeBackend,
+  EndpointGenerator,
+  createBackend,
+  createCompositeService,
+  createLocalService,
+  createRemoteService
+} from "./chunk-P4HL4C6V.js";
 import {
   CANONICAL_SRKL_URL,
   SrklClient,
@@ -7,14 +15,6 @@ import {
   srklListBackblazeBuckets,
   useSrklServices
 } from "./chunk-MN54ZIKZ.js";
-import {
-  CompositeBackend,
-  EndpointGenerator,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService
-} from "./chunk-P4HL4C6V.js";
 import "./chunk-LS3HWJBX.js";
 import {
   authorizeB2,

package/packages/contracts/dist/index.d.ts

@@ -0,0 +1,552 @@
+import { z } from 'zod';
+
+/**
+ * @file surface.ts
+ * @description Canonical export surface definitions and consumer compatibility validator.
+ * Enforces: QwnsrRequiredSurface ⊆ KloksPublicContract
+ */
+interface ExportSymbolEntry {
+    name: string;
+    subpath: string;
+    category: 'state-graph' | 'audio-midi' | 'orchestrations' | 'backend' | 'services' | 'functions' | 'contracts';
+    hasZodSchema: boolean;
+}
+/**
+ * Authoritative Canonical Public Contract Surface for Kloks.
+ */
+declare const KLOKS_PUBLIC_SURFACE: ExportSymbolEntry[];
+/**
+ * Surface required by Qwnsr consumer according to docs/01_CONTRACT_FOUNDATION.md & docs/03_LIBRARY_CONTRACT_MIGRATION.md.
+ */
+declare const QWNSR_REQUIRED_SURFACE: string[];
+interface CompatibilityCheckResult {
+    compatible: boolean;
+    missingSymbols: string[];
+    totalRequired: number;
+    totalPresent: number;
+}
+/**
+ * Verifies that all symbols in requiredSurface are exported by Kloks.
+ * Enforces Invariant: QwnsrRequiredSurface ⊆ KloksPublicContract
+ */
+declare function validateConsumerSurfaceCompatibility(requiredSymbols?: string[], publicSurface?: ExportSymbolEntry[]): CompatibilityCheckResult;
+
+/**
+ * @file schemas.ts
+ * @description Runtime Zod Schemas for Kloks Public Contracts and Canonical Models.
+ * Enforces: ∀ public runtime boundary: TypeScriptContract ∧ ZodRuntimeContract
+ */
+
+declare const GraphEntityMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    archetype: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+    customAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: string;
+    id?: string;
+    name?: string;
+    archetype?: string;
+    tags?: string[];
+    description?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    customAttributes?: Record<string, unknown>;
+}, {
+    type?: string;
+    id?: string;
+    name?: string;
+    archetype?: string;
+    tags?: string[];
+    description?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    customAttributes?: Record<string, unknown>;
+}>;
+type GraphEntityMetadata = z.infer<typeof GraphEntityMetadataSchema>;
+declare const SocketPosition2DSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x?: number;
+    y?: number;
+}, {
+    x?: number;
+    y?: number;
+}>;
+type SocketPosition2D = z.infer<typeof SocketPosition2DSchema>;
+declare const SocketDirectionSchema: z.ZodEnum<["input", "output", "bidirectional"]>;
+type SocketDirection = z.infer<typeof SocketDirectionSchema>;
+declare const SocketGeometryConfigSchema: z.ZodObject<{
+    radius: z.ZodDefault<z.ZodNumber>;
+    hitRadius: z.ZodDefault<z.ZodNumber>;
+    snapDistance: z.ZodDefault<z.ZodNumber>;
+    direction: z.ZodDefault<z.ZodEnum<["input", "output", "bidirectional"]>>;
+    relativeOffset: z.ZodDefault<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x?: number;
+        y?: number;
+    }, {
+        x?: number;
+        y?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    radius?: number;
+    hitRadius?: number;
+    snapDistance?: number;
+    direction?: "input" | "output" | "bidirectional";
+    relativeOffset?: {
+        x?: number;
+        y?: number;
+    };
+}, {
+    radius?: number;
+    hitRadius?: number;
+    snapDistance?: number;
+    direction?: "input" | "output" | "bidirectional";
+    relativeOffset?: {
+        x?: number;
+        y?: number;
+    };
+}>;
+type SocketGeometryConfig = z.infer<typeof SocketGeometryConfigSchema>;
+declare const SocketStyleConfigSchema: z.ZodObject<{
+    color: z.ZodString;
+    hoverColor: z.ZodOptional<z.ZodString>;
+    activeColor: z.ZodOptional<z.ZodString>;
+    borderColor: z.ZodOptional<z.ZodString>;
+    borderWidth: z.ZodOptional<z.ZodNumber>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    color?: string;
+    hoverColor?: string;
+    activeColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    fillOpacity?: number;
+}, {
+    color?: string;
+    hoverColor?: string;
+    activeColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    fillOpacity?: number;
+}>;
+type SocketStyleConfig = z.infer<typeof SocketStyleConfigSchema>;
+declare const WireEndpoint2DSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    socketId: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x?: number;
+        y?: number;
+    }, {
+        x?: number;
+        y?: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    nodeId?: string;
+    socketId?: string;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+}, {
+    nodeId?: string;
+    socketId?: string;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+}>;
+type WireEndpoint2D = z.infer<typeof WireEndpoint2DSchema>;
+declare const WireCurveStyleSchema: z.ZodEnum<["bezier", "linear", "orthogonal", "stepped"]>;
+type WireCurveStyle = z.infer<typeof WireCurveStyleSchema>;
+declare const WireAnimationConfigSchema: z.ZodObject<{
+    animated: z.ZodDefault<z.ZodBoolean>;
+    speed: z.ZodDefault<z.ZodNumber>;
+    direction: z.ZodDefault<z.ZodEnum<["forward", "reverse"]>>;
+    pulseFrequency: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    direction?: "reverse" | "forward";
+    animated?: boolean;
+    speed?: number;
+    pulseFrequency?: number;
+}, {
+    direction?: "reverse" | "forward";
+    animated?: boolean;
+    speed?: number;
+    pulseFrequency?: number;
+}>;
+type WireAnimationConfig = z.infer<typeof WireAnimationConfigSchema>;
+declare const WireVisualConfigSchema: z.ZodObject<{
+    strokeColor: z.ZodString;
+    strokeWidth: z.ZodDefault<z.ZodNumber>;
+    strokeDashArray: z.ZodOptional<z.ZodString>;
+    curveStyle: z.ZodDefault<z.ZodEnum<["bezier", "linear", "orthogonal", "stepped"]>>;
+    curvature: z.ZodDefault<z.ZodNumber>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+    glow: z.ZodDefault<z.ZodBoolean>;
+    glowColor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeDashArray?: string;
+    curveStyle?: "bezier" | "linear" | "orthogonal" | "stepped";
+    curvature?: number;
+    opacity?: number;
+    glow?: boolean;
+    glowColor?: string;
+}, {
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeDashArray?: string;
+    curveStyle?: "bezier" | "linear" | "orthogonal" | "stepped";
+    curvature?: number;
+    opacity?: number;
+    glow?: boolean;
+    glowColor?: string;
+}>;
+type WireVisualConfig = z.infer<typeof WireVisualConfigSchema>;
+declare const NodeDimensions2DSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    minWidth: z.ZodOptional<z.ZodNumber>;
+    minHeight: z.ZodOptional<z.ZodNumber>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+    maxHeight: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}, {
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}>;
+type NodeDimensions2D = z.infer<typeof NodeDimensions2DSchema>;
+declare const NodeScreenRect2DSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}, {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}>;
+type NodeScreenRect2D = z.infer<typeof NodeScreenRect2DSchema>;
+declare const NodeHeaderStyleSchema: z.ZodObject<{
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    titleColor: z.ZodOptional<z.ZodString>;
+    iconColor: z.ZodOptional<z.ZodString>;
+    badgeColor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    backgroundColor?: string;
+    titleColor?: string;
+    iconColor?: string;
+    badgeColor?: string;
+}, {
+    backgroundColor?: string;
+    titleColor?: string;
+    iconColor?: string;
+    badgeColor?: string;
+}>;
+type NodeHeaderStyle = z.infer<typeof NodeHeaderStyleSchema>;
+declare const AudioBusConfigSchema: z.ZodObject<{
+    channelCount: z.ZodDefault<z.ZodNumber>;
+    sampleRate: z.ZodDefault<z.ZodNumber>;
+    bufferSize: z.ZodDefault<z.ZodNumber>;
+    latencyHint: z.ZodDefault<z.ZodEnum<["interactive", "balanced", "playback"]>>;
+}, "strip", z.ZodTypeAny, {
+    channelCount?: number;
+    sampleRate?: number;
+    bufferSize?: number;
+    latencyHint?: "interactive" | "balanced" | "playback";
+}, {
+    channelCount?: number;
+    sampleRate?: number;
+    bufferSize?: number;
+    latencyHint?: "interactive" | "balanced" | "playback";
+}>;
+type AudioBusConfig = z.infer<typeof AudioBusConfigSchema>;
+declare const AudioHardwareStateSchema: z.ZodObject<{
+    contextState: z.ZodEnum<["suspended", "running", "closed", "uninitialized"]>;
+    sampleRate: z.ZodNumber;
+    inputChannels: z.ZodNumber;
+    outputChannels: z.ZodNumber;
+    activeInputDeviceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    activeOutputDeviceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    sampleRate?: number;
+    contextState?: "suspended" | "running" | "closed" | "uninitialized";
+    inputChannels?: number;
+    outputChannels?: number;
+    activeInputDeviceId?: string;
+    activeOutputDeviceId?: string;
+}, {
+    sampleRate?: number;
+    contextState?: "suspended" | "running" | "closed" | "uninitialized";
+    inputChannels?: number;
+    outputChannels?: number;
+    activeInputDeviceId?: string;
+    activeOutputDeviceId?: string;
+}>;
+type AudioHardwareState = z.infer<typeof AudioHardwareStateSchema>;
+declare const MidiCommandTypeSchema: z.ZodEnum<["NOTE_ON", "NOTE_OFF", "CONTROL_CHANGE", "PITCH_BEND", "PROGRAM_CHANGE", "AFTERTOUCH", "POLY_PRESSURE", "CLOCK", "START", "CONTINUE", "STOP", "ACTIVE_SENSING", "SYSTEM_RESET"]>;
+type MidiCommandType = z.infer<typeof MidiCommandTypeSchema>;
+declare const MidiEventPayloadSchema: z.ZodObject<{
+    command: z.ZodEnum<["NOTE_ON", "NOTE_OFF", "CONTROL_CHANGE", "PITCH_BEND", "PROGRAM_CHANGE", "AFTERTOUCH", "POLY_PRESSURE", "CLOCK", "START", "CONTINUE", "STOP", "ACTIVE_SENSING", "SYSTEM_RESET"]>;
+    channel: z.ZodDefault<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodNumber>;
+    velocity: z.ZodOptional<z.ZodNumber>;
+    controller: z.ZodOptional<z.ZodNumber>;
+    value: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timestamp?: number;
+    value?: number;
+    command?: "NOTE_ON" | "NOTE_OFF" | "CONTROL_CHANGE" | "PITCH_BEND" | "PROGRAM_CHANGE" | "AFTERTOUCH" | "POLY_PRESSURE" | "CLOCK" | "START" | "CONTINUE" | "STOP" | "ACTIVE_SENSING" | "SYSTEM_RESET";
+    channel?: number;
+    note?: number;
+    velocity?: number;
+    controller?: number;
+}, {
+    timestamp?: number;
+    value?: number;
+    command?: "NOTE_ON" | "NOTE_OFF" | "CONTROL_CHANGE" | "PITCH_BEND" | "PROGRAM_CHANGE" | "AFTERTOUCH" | "POLY_PRESSURE" | "CLOCK" | "START" | "CONTINUE" | "STOP" | "ACTIVE_SENSING" | "SYSTEM_RESET";
+    channel?: number;
+    note?: number;
+    velocity?: number;
+    controller?: number;
+}>;
+type MidiEventPayload = z.infer<typeof MidiEventPayloadSchema>;
+declare const BackendOperationSchema: z.ZodObject<{
+    name: z.ZodString;
+    service: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchemaName: z.ZodOptional<z.ZodString>;
+    outputSchemaName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    description?: string;
+    service?: string;
+    inputSchemaName?: string;
+    outputSchemaName?: string;
+}, {
+    name?: string;
+    description?: string;
+    service?: string;
+    inputSchemaName?: string;
+    outputSchemaName?: string;
+}>;
+type BackendOperation = z.infer<typeof BackendOperationSchema>;
+declare const PublicContractDefinitionSchema: z.ZodObject<{
+    package: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    exports: z.ZodRecord<z.ZodString, z.ZodObject<{
+        types: z.ZodString;
+        import: z.ZodString;
+        default: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        types?: string;
+        import?: string;
+        default?: string;
+    }, {
+        types?: string;
+        import?: string;
+        default?: string;
+    }>>;
+    symbols: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        subpath: z.ZodString;
+        kind: z.ZodEnum<["class", "type", "interface", "function", "const", "object"]>;
+        hasZodSchema: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        subpath?: string;
+        kind?: "object" | "function" | "type" | "class" | "interface" | "const";
+        hasZodSchema?: boolean;
+    }, {
+        name?: string;
+        subpath?: string;
+        kind?: "object" | "function" | "type" | "class" | "interface" | "const";
+        hasZodSchema?: boolean;
+    }>, "many">;
+    facades: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        subpath: z.ZodString;
+        runtime: z.ZodEnum<["client", "server"]>;
+        deployment: z.ZodEnum<["local", "remote"]>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        name?: string;
+        subpath?: string;
+        runtime?: "client" | "server";
+        deployment?: "local" | "remote";
+    }, {
+        id?: string;
+        name?: string;
+        subpath?: string;
+        runtime?: "client" | "server";
+        deployment?: "local" | "remote";
+    }>, "many">;
+    invariants: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    package?: string;
+    version?: string;
+    facades?: {
+        id?: string;
+        name?: string;
+        subpath?: string;
+        runtime?: "client" | "server";
+        deployment?: "local" | "remote";
+    }[];
+    description?: string;
+    exports?: Record<string, {
+        types?: string;
+        import?: string;
+        default?: string;
+    }>;
+    symbols?: {
+        name?: string;
+        subpath?: string;
+        kind?: "object" | "function" | "type" | "class" | "interface" | "const";
+        hasZodSchema?: boolean;
+    }[];
+    invariants?: string[];
+}, {
+    package?: string;
+    version?: string;
+    facades?: {
+        id?: string;
+        name?: string;
+        subpath?: string;
+        runtime?: "client" | "server";
+        deployment?: "local" | "remote";
+    }[];
+    description?: string;
+    exports?: Record<string, {
+        types?: string;
+        import?: string;
+        default?: string;
+    }>;
+    symbols?: {
+        name?: string;
+        subpath?: string;
+        kind?: "object" | "function" | "type" | "class" | "interface" | "const";
+        hasZodSchema?: boolean;
+    }[];
+    invariants?: string[];
+}>;
+type PublicContractDefinition = z.infer<typeof PublicContractDefinitionSchema>;
+declare const ContractSnapshotSchema: z.ZodObject<{
+    package: z.ZodString;
+    version: z.ZodString;
+    timestamp: z.ZodNumber;
+    checksum: z.ZodString;
+    publicSymbols: z.ZodArray<z.ZodString, "many">;
+    normalizedSignatures: z.ZodRecord<z.ZodString, z.ZodString>;
+    zodFingerprints: z.ZodRecord<z.ZodString, z.ZodString>;
+    facades: z.ZodArray<z.ZodString, "many">;
+    events: z.ZodArray<z.ZodString, "many">;
+    commands: z.ZodArray<z.ZodString, "many">;
+    errorCodes: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    package?: string;
+    version?: string;
+    timestamp?: number;
+    checksum?: string;
+    publicSymbols?: string[];
+    normalizedSignatures?: Record<string, string>;
+    zodFingerprints?: Record<string, string>;
+    facades?: string[];
+    events?: string[];
+    commands?: string[];
+    errorCodes?: string[];
+}, {
+    package?: string;
+    version?: string;
+    timestamp?: number;
+    checksum?: string;
+    publicSymbols?: string[];
+    normalizedSignatures?: Record<string, string>;
+    zodFingerprints?: Record<string, string>;
+    facades?: string[];
+    events?: string[];
+    commands?: string[];
+    errorCodes?: string[];
+}>;
+type ContractSnapshot = z.infer<typeof ContractSnapshotSchema>;
+
+/**
+ * @file snapshot.ts
+ * @description Contract snapshot generator, diff engine, and semantic versioning rules.
+ * Enforces:
+ *   implementation_only      => PATCH
+ *   additive_compatible       => MINOR
+ *   breaking_contract_change => MAJOR
+ */
+
+interface ContractDiffResult {
+    versionRecommendation: 'PATCH' | 'MINOR' | 'MAJOR';
+    hasBreakingChanges: boolean;
+    hasAdditiveChanges: boolean;
+    isIdentical: boolean;
+    removedSymbols: string[];
+    addedSymbols: string[];
+    changedSignatures: string[];
+    summary: string;
+}
+/**
+ * Generate canonical contract snapshot for Kloks.
+ */
+declare function createKloksSnapshot(version?: string, surface?: ExportSymbolEntry[]): ContractSnapshot;
+/**
+ * Computes semantic diff between previous and current contract snapshots.
+ */
+declare function diffContractSnapshots(previous: ContractSnapshot, current: ContractSnapshot): ContractDiffResult;
+
+declare const KLOKS_CANONICAL_CONTRACT: {
+    package: string;
+    version: string;
+    getSnapshot: () => {
+        package?: string;
+        version?: string;
+        timestamp?: number;
+        checksum?: string;
+        publicSymbols?: string[];
+        normalizedSignatures?: Record<string, string>;
+        zodFingerprints?: Record<string, string>;
+        facades?: string[];
+        events?: string[];
+        commands?: string[];
+        errorCodes?: string[];
+    };
+    validateCompatibility: (consumerSymbols?: string[]) => CompatibilityCheckResult;
+};
+
+export { type AudioBusConfig, AudioBusConfigSchema, type AudioHardwareState, AudioHardwareStateSchema, type BackendOperation, BackendOperationSchema, type CompatibilityCheckResult, type ContractDiffResult, type ContractSnapshot, ContractSnapshotSchema, type ExportSymbolEntry, type GraphEntityMetadata, GraphEntityMetadataSchema, KLOKS_CANONICAL_CONTRACT, KLOKS_PUBLIC_SURFACE, type MidiCommandType, MidiCommandTypeSchema, type MidiEventPayload, MidiEventPayloadSchema, type NodeDimensions2D, NodeDimensions2DSchema, type NodeHeaderStyle, NodeHeaderStyleSchema, type NodeScreenRect2D, NodeScreenRect2DSchema, type PublicContractDefinition, PublicContractDefinitionSchema, QWNSR_REQUIRED_SURFACE, type SocketDirection, SocketDirectionSchema, type SocketGeometryConfig, SocketGeometryConfigSchema, type SocketPosition2D, SocketPosition2DSchema, type SocketStyleConfig, SocketStyleConfigSchema, type WireAnimationConfig, WireAnimationConfigSchema, type WireCurveStyle, WireCurveStyleSchema, type WireEndpoint2D, WireEndpoint2DSchema, type WireVisualConfig, WireVisualConfigSchema, createKloksSnapshot, diffContractSnapshots, validateConsumerSurfaceCompatibility };

package/packages/contracts/dist/index.js

@@ -0,0 +1,422 @@
+// src/schemas.ts
+import { z } from "zod";
+var GraphEntityMetadataSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string(),
+  archetype: z.string(),
+  tags: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional(),
+  customAttributes: z.record(z.unknown()).optional()
+});
+var SocketPosition2DSchema = z.object({
+  x: z.number(),
+  y: z.number()
+});
+var SocketDirectionSchema = z.enum(["input", "output", "bidirectional"]);
+var SocketGeometryConfigSchema = z.object({
+  radius: z.number().default(6),
+  hitRadius: z.number().default(12),
+  snapDistance: z.number().default(18),
+  direction: SocketDirectionSchema.default("input"),
+  relativeOffset: SocketPosition2DSchema.default({ x: 0, y: 0 })
+});
+var SocketStyleConfigSchema = z.object({
+  color: z.string(),
+  hoverColor: z.string().optional(),
+  activeColor: z.string().optional(),
+  borderColor: z.string().optional(),
+  borderWidth: z.number().optional(),
+  fillOpacity: z.number().optional()
+});
+var WireEndpoint2DSchema = z.object({
+  nodeId: z.string(),
+  socketId: z.string(),
+  position: SocketPosition2DSchema
+});
+var WireCurveStyleSchema = z.enum(["bezier", "linear", "orthogonal", "stepped"]);
+var WireAnimationConfigSchema = z.object({
+  animated: z.boolean().default(false),
+  speed: z.number().default(1),
+  direction: z.enum(["forward", "reverse"]).default("forward"),
+  pulseFrequency: z.number().optional()
+});
+var WireVisualConfigSchema = z.object({
+  strokeColor: z.string(),
+  strokeWidth: z.number().default(2),
+  strokeDashArray: z.string().optional(),
+  curveStyle: WireCurveStyleSchema.default("bezier"),
+  curvature: z.number().default(0.5),
+  opacity: z.number().default(1),
+  glow: z.boolean().default(false),
+  glowColor: z.string().optional()
+});
+var NodeDimensions2DSchema = z.object({
+  width: z.number(),
+  height: z.number(),
+  minWidth: z.number().optional(),
+  minHeight: z.number().optional(),
+  maxWidth: z.number().optional(),
+  maxHeight: z.number().optional()
+});
+var NodeScreenRect2DSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number()
+});
+var NodeHeaderStyleSchema = z.object({
+  backgroundColor: z.string().optional(),
+  titleColor: z.string().optional(),
+  iconColor: z.string().optional(),
+  badgeColor: z.string().optional()
+});
+var AudioBusConfigSchema = z.object({
+  channelCount: z.number().default(2),
+  sampleRate: z.number().default(44100),
+  bufferSize: z.number().default(512),
+  latencyHint: z.enum(["interactive", "balanced", "playback"]).default("interactive")
+});
+var AudioHardwareStateSchema = z.object({
+  contextState: z.enum(["suspended", "running", "closed", "uninitialized"]),
+  sampleRate: z.number(),
+  inputChannels: z.number(),
+  outputChannels: z.number(),
+  activeInputDeviceId: z.string().nullable().optional(),
+  activeOutputDeviceId: z.string().nullable().optional()
+});
+var MidiCommandTypeSchema = z.enum([
+  "NOTE_ON",
+  "NOTE_OFF",
+  "CONTROL_CHANGE",
+  "PITCH_BEND",
+  "PROGRAM_CHANGE",
+  "AFTERTOUCH",
+  "POLY_PRESSURE",
+  "CLOCK",
+  "START",
+  "CONTINUE",
+  "STOP",
+  "ACTIVE_SENSING",
+  "SYSTEM_RESET"
+]);
+var MidiEventPayloadSchema = z.object({
+  command: MidiCommandTypeSchema,
+  channel: z.number().min(1).max(16).default(1),
+  note: z.number().min(0).max(127).optional(),
+  velocity: z.number().min(0).max(127).optional(),
+  controller: z.number().min(0).max(127).optional(),
+  value: z.number().min(0).max(127).optional(),
+  timestamp: z.number().optional()
+});
+var BackendOperationSchema = z.object({
+  name: z.string(),
+  service: z.string(),
+  description: z.string().optional(),
+  inputSchemaName: z.string().optional(),
+  outputSchemaName: z.string().optional()
+});
+var PublicContractDefinitionSchema = z.object({
+  package: z.string(),
+  version: z.string(),
+  description: z.string(),
+  exports: z.record(z.object({
+    types: z.string(),
+    import: z.string(),
+    default: z.string()
+  })),
+  symbols: z.array(z.object({
+    name: z.string(),
+    subpath: z.string(),
+    kind: z.enum(["class", "type", "interface", "function", "const", "object"]),
+    hasZodSchema: z.boolean()
+  })),
+  facades: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    subpath: z.string(),
+    runtime: z.enum(["client", "server"]),
+    deployment: z.enum(["local", "remote"])
+  })),
+  invariants: z.array(z.string())
+});
+var ContractSnapshotSchema = z.object({
+  package: z.string(),
+  version: z.string(),
+  timestamp: z.number(),
+  checksum: z.string(),
+  publicSymbols: z.array(z.string()),
+  normalizedSignatures: z.record(z.string()),
+  zodFingerprints: z.record(z.string()),
+  facades: z.array(z.string()),
+  events: z.array(z.string()),
+  commands: z.array(z.string()),
+  errorCodes: z.array(z.string())
+});
+
+// src/surface.ts
+var KLOKS_PUBLIC_SURFACE = [
+  // ── state-graph ──
+  { name: "GraphEntityParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "GraphEntityMetadata", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "GraphSocketParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "SocketDirection", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "SocketPosition2D", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "SocketGeometryConfig", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "SocketStyleConfig", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "AudioStereoSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "AudioMonoSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "AudioPacketSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "TriggerSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "MidiStreamSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "MidiPacketSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "CurveStreamSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "CurvePacketSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ComponentSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "PrimitiveSocket", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createSocketInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createQwnsrSocketInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "GraphWireParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "WireEndpoint2D", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "WireCurveStyle", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "WireAnimationConfig", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "WireVisualConfig", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "AudioStereoWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "AudioMonoWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "AudioPacketWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "TriggerWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "MidiStreamWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "MidiPacketWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "CurveStreamWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "CurvePacketWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ComponentWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "PrimitiveWire", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createWireInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createQwnsrWireInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "GraphNodeParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "DataProcessingNodeParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "SignalGeneratorNodeParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "RoutingNodeParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ControlNodeParent", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "NodeDimensions2D", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "NodeScreenRect2D", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "NodeHeaderStyle", subpath: "state-graph", category: "state-graph", hasZodSchema: true },
+  { name: "TriggerNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ContainerNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ModuleNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "EffectNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "CodeNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ArrangementNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "RouterNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "StripNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "ControlNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "PrimitiveNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "GroupNodeModel", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createNodeInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "createQwnsrNodeInstance", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "StateLifecycleServiceFacade", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "NodeGraphEngineServiceFacade", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  { name: "PredictiveGraphServiceFacade", subpath: "state-graph", category: "state-graph", hasZodSchema: false },
+  // ── audio-midi ──
+  { name: "AudioInputManager", subpath: "audio-midi", category: "audio-midi", hasZodSchema: false },
+  { name: "MidiManager", subpath: "audio-midi", category: "audio-midi", hasZodSchema: false },
+  { name: "AudioHardwareServiceFacade", subpath: "audio-midi", category: "audio-midi", hasZodSchema: false },
+  { name: "MidiServiceFacade", subpath: "audio-midi", category: "audio-midi", hasZodSchema: false },
+  { name: "AudioMidiOrchestratorFacade", subpath: "audio-midi", category: "audio-midi", hasZodSchema: false },
+  { name: "AudioBusConfig", subpath: "audio-midi", category: "audio-midi", hasZodSchema: true },
+  { name: "AudioHardwareState", subpath: "audio-midi", category: "audio-midi", hasZodSchema: true },
+  { name: "MidiCommandType", subpath: "audio-midi", category: "audio-midi", hasZodSchema: true },
+  { name: "MidiEventPayload", subpath: "audio-midi", category: "audio-midi", hasZodSchema: true },
+  // ── orchestrations ──
+  { name: "OrchestratorAFacade", subpath: "orchestrations", category: "orchestrations", hasZodSchema: false },
+  { name: "OrchestratorBFacade", subpath: "orchestrations", category: "orchestrations", hasZodSchema: false },
+  { name: "WorkspaceBackendFacade", subpath: "orchestrations", category: "orchestrations", hasZodSchema: false },
+  { name: "backendFacade", subpath: "orchestrations", category: "orchestrations", hasZodSchema: false },
+  { name: "workerExecutionBoundary", subpath: "orchestrations", category: "orchestrations", hasZodSchema: false },
+  // ── backend ──
+  { name: "AuthServiceFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  { name: "StorageServiceFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  { name: "WorkspaceServiceFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  { name: "ControlPlaneServiceFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  { name: "ExecutionServiceFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  { name: "ExecutableBackendFacade", subpath: "backend", category: "backend", hasZodSchema: false },
+  // ── services ──
+  { name: "ServiceAFacade", subpath: "services", category: "services", hasZodSchema: false },
+  { name: "ServiceBFacade", subpath: "services", category: "services", hasZodSchema: false },
+  { name: "ServiceCFacade", subpath: "services", category: "services", hasZodSchema: false },
+  { name: "ServiceDFacade", subpath: "services", category: "services", hasZodSchema: false },
+  // ── functions ──
+  { name: "FunctionsServiceFacade", subpath: "functions", category: "functions", hasZodSchema: false },
+  { name: "toKebabCase", subpath: "functions", category: "functions", hasZodSchema: false },
+  { name: "safeJsonParse", subpath: "functions", category: "functions", hasZodSchema: false },
+  // ── contracts ──
+  { name: "KLOKS_CANONICAL_CONTRACT", subpath: "contracts", category: "contracts", hasZodSchema: true },
+  { name: "createKloksSnapshot", subpath: "contracts", category: "contracts", hasZodSchema: true },
+  { name: "diffContractSnapshots", subpath: "contracts", category: "contracts", hasZodSchema: true },
+  { name: "validateConsumerSurfaceCompatibility", subpath: "contracts", category: "contracts", hasZodSchema: true }
+];
+var QWNSR_REQUIRED_SURFACE = [
+  "GraphEntityMetadata",
+  "SocketPosition2D",
+  "SocketDirection",
+  "SocketGeometryConfig",
+  "SocketStyleConfig",
+  "AudioStereoSocket",
+  "AudioMonoSocket",
+  "TriggerSocket",
+  "createSocketInstance",
+  "GraphWireParent",
+  "WireEndpoint2D",
+  "WireVisualConfig",
+  "createWireInstance",
+  "GraphNodeParent",
+  "NodeDimensions2D",
+  "createNodeInstance",
+  "StateLifecycleServiceFacade",
+  "NodeGraphEngineServiceFacade",
+  "WorkspaceBackendFacade",
+  "AudioHardwareServiceFacade",
+  "MidiServiceFacade",
+  "AudioMidiOrchestratorFacade"
+];
+function validateConsumerSurfaceCompatibility(requiredSymbols = QWNSR_REQUIRED_SURFACE, publicSurface = KLOKS_PUBLIC_SURFACE) {
+  const publicNames = new Set(publicSurface.map((s) => s.name));
+  const missingSymbols = requiredSymbols.filter((s) => !publicNames.has(s));
+  return {
+    compatible: missingSymbols.length === 0,
+    missingSymbols,
+    totalRequired: requiredSymbols.length,
+    totalPresent: requiredSymbols.length - missingSymbols.length
+  };
+}
+
+// src/snapshot.ts
+function createKloksSnapshot(version = "1.0.2", surface = KLOKS_PUBLIC_SURFACE) {
+  const publicSymbols = surface.map((s) => s.name).sort();
+  const normalizedSignatures = {};
+  const zodFingerprints = {};
+  for (const item of surface) {
+    normalizedSignatures[item.name] = `${item.category}:${item.subpath}`;
+    zodFingerprints[item.name] = item.hasZodSchema ? "zod-verified" : "typescript-only";
+  }
+  const facades = surface.filter((s) => s.name.endsWith("Facade") || s.name.endsWith("facade")).map((s) => s.name).sort();
+  const events = [
+    "AudioServiceEvents.stateChange",
+    "MidiServiceEvents.midiEvent",
+    "TelemetryEvents.reading"
+  ];
+  const commands = [
+    "WorkspaceBackendFacade.project.list",
+    "WorkspaceBackendFacade.project.get",
+    "WorkspaceBackendFacade.project.save",
+    "WorkspaceBackendFacade.project.create",
+    "WorkspaceBackendFacade.project.delete",
+    "WorkspaceBackendFacade.sample.list",
+    "WorkspaceBackendFacade.sample.upload",
+    "WorkspaceBackendFacade.sample.delete",
+    "WorkspaceBackendFacade.asset.listPool",
+    "WorkspaceBackendFacade.asset.createFolder",
+    "WorkspaceBackendFacade.asset.upload",
+    "WorkspaceBackendFacade.asset.delete"
+  ];
+  const errorCodes = [
+    "ERR_CONTRACT_VIOLATION",
+    "ERR_INTERNAL_IMPORT_FORBIDDEN",
+    "ERR_LOCAL_SHIM_DETECTED",
+    "ERR_INCOMPATIBLE_SURFACE"
+  ];
+  const rawJson = JSON.stringify({ publicSymbols, facades, commands, events });
+  let hash = 0;
+  for (let i = 0; i < rawJson.length; i++) {
+    hash = (hash << 5) - hash + rawJson.charCodeAt(i);
+    hash |= 0;
+  }
+  const checksum = `sha256-${Math.abs(hash).toString(16)}`;
+  const snapshot = {
+    package: "@ultrst-armada/kloks",
+    version,
+    timestamp: 1760377e6,
+    checksum,
+    publicSymbols,
+    normalizedSignatures,
+    zodFingerprints,
+    facades,
+    events,
+    commands,
+    errorCodes
+  };
+  return ContractSnapshotSchema.parse(snapshot);
+}
+function diffContractSnapshots(previous, current) {
+  const prevSymbols = new Set(previous.publicSymbols);
+  const currSymbols = new Set(current.publicSymbols);
+  const removedSymbols = previous.publicSymbols.filter((s) => !currSymbols.has(s));
+  const addedSymbols = current.publicSymbols.filter((s) => !prevSymbols.has(s));
+  const changedSignatures = [];
+  for (const s of current.publicSymbols) {
+    if (prevSymbols.has(s)) {
+      const prevSig = previous.normalizedSignatures[s];
+      const currSig = current.normalizedSignatures[s];
+      if (prevSig && currSig && prevSig !== currSig) {
+        changedSignatures.push(`${s} (${prevSig} -> ${currSig})`);
+      }
+    }
+  }
+  const hasBreakingChanges = removedSymbols.length > 0;
+  const hasAdditiveChanges = addedSymbols.length > 0 || changedSignatures.length > 0;
+  const isIdentical = !hasBreakingChanges && !hasAdditiveChanges;
+  let versionRecommendation = "PATCH";
+  if (hasBreakingChanges) {
+    versionRecommendation = "MAJOR";
+  } else if (hasAdditiveChanges) {
+    versionRecommendation = "MINOR";
+  }
+  const summary = isIdentical ? "Identical public contract surface (PATCH compatible)." : hasBreakingChanges ? `Breaking contract change detected: ${removedSymbols.length} removed symbols (MAJOR bump required).` : `Additive compatible changes: ${addedSymbols.length} added symbols (MINOR bump required).`;
+  return {
+    versionRecommendation,
+    hasBreakingChanges,
+    hasAdditiveChanges,
+    isIdentical,
+    removedSymbols,
+    addedSymbols,
+    changedSignatures,
+    summary
+  };
+}
+
+// src/index.ts
+var KLOKS_CANONICAL_CONTRACT = {
+  package: "@ultrst-armada/kloks",
+  version: "1.0.2",
+  getSnapshot: () => createKloksSnapshot("1.0.2", KLOKS_PUBLIC_SURFACE),
+  validateCompatibility: (consumerSymbols) => validateConsumerSurfaceCompatibility(consumerSymbols ?? QWNSR_REQUIRED_SURFACE, KLOKS_PUBLIC_SURFACE)
+};
+export {
+  AudioBusConfigSchema,
+  AudioHardwareStateSchema,
+  BackendOperationSchema,
+  ContractSnapshotSchema,
+  GraphEntityMetadataSchema,
+  KLOKS_CANONICAL_CONTRACT,
+  KLOKS_PUBLIC_SURFACE,
+  MidiCommandTypeSchema,
+  MidiEventPayloadSchema,
+  NodeDimensions2DSchema,
+  NodeHeaderStyleSchema,
+  NodeScreenRect2DSchema,
+  PublicContractDefinitionSchema,
+  QWNSR_REQUIRED_SURFACE,
+  SocketDirectionSchema,
+  SocketGeometryConfigSchema,
+  SocketPosition2DSchema,
+  SocketStyleConfigSchema,
+  WireAnimationConfigSchema,
+  WireCurveStyleSchema,
+  WireEndpoint2DSchema,
+  WireVisualConfigSchema,
+  createKloksSnapshot,
+  diffContractSnapshots,
+  validateConsumerSurfaceCompatibility
+};

package/packages/contracts/kloks.manifest.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://skipo.dev/schemas/kloks-manifest.v1.json",
+  "package": "@kloks/contracts",
+  "version": "1.0.0",
+  "services": [
+    {
+      "id": "canonical-contracts",
+      "name": "Canonical Contract & Snapshot Engine",
+      "version": "1.0.0",
+      "description": "Zod runtime schemas, export manifests, and contract snapshot diff engine.",
+      "backend": {
+        "package": "@kloks/contracts",
+        "export": "KLOKS_CANONICAL_CONTRACT",
+        "facade": "KLOKS_CANONICAL_CONTRACT"
+      },
+      "modes": ["backend"],
+      "targets": { "backend": ["BackendFacade.contracts"] }
+    }
+  ]
+}

package/packages/contracts/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@kloks/contracts",
+  "version": "1.0.0",
+  "description": "Kloks Canonical Public Contracts, Zod Runtime Schemas, and Snapshot/Diff Validation Engine",
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "skipoManifest": "./kloks.manifest.json",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --external zod",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@ultrst-armada/krnl": "^1.0.0"
+  }
+}

package/packages/state-graph/dist/index.js

@@ -19,6 +19,21 @@ import {
   WireTypeRegistry,
   initializeDefaultGraphRules
 } from "./chunk-QN74PLMF.js";
+import "./chunk-Q5I42UX7.js";
+import {
+  LifecycleCycleError,
+  LifecycleGraph,
+  SKIPO_STATE,
+  SkipoStateEngine,
+  useLifecycleScope,
+  useSkipoBind,
+  useSkipoState
+} from "./chunk-SHIBCPGQ.js";
+import {
+  AttractionEngine,
+  calculateSocketCoordinates,
+  getBeamPoints
+} from "./chunk-YTWCH6P2.js";
 import {
   CommandApi,
   GhostStore,
@@ -33,11 +48,6 @@ import {
   CustomViewWindow,
   DEFAULT_GRAPH_SETTINGS
 } from "./chunk-KG6QYS26.js";
-import {
-  AttractionEngine,
-  calculateSocketCoordinates,
-  getBeamPoints
-} from "./chunk-YTWCH6P2.js";
 import {
   AutoSolidify,
   SpatialEngine,
@@ -51,16 +61,6 @@ import {
 import {
   CompatibilityMatrix
 } from "./chunk-ISFNY7EZ.js";
-import "./chunk-Q5I42UX7.js";
-import {
-  LifecycleCycleError,
-  LifecycleGraph,
-  SKIPO_STATE,
-  SkipoStateEngine,
-  useLifecycleScope,
-  useSkipoBind,
-  useSkipoState
-} from "./chunk-SHIBCPGQ.js";
 import "./chunk-3RG5ZIWI.js";
 
 // ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.0/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js