@manifesto-ai/core 2.13.0 → 5.1.0

package/dist/schema/result.d.ts

@@ -31,7 +31,7 @@ export declare const SystemDelta: z.ZodObject<{
         timestamp: z.ZodNumber;
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
-    addRequirements: z.ZodArray<z.ZodObject<{
+    addRequirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         type: z.ZodString;
         params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -41,10 +41,49 @@ export declare const SystemDelta: z.ZodObject<{
             snapshotVersion: z.ZodNumber;
         }, z.core.$strip>;
         createdAt: z.ZodNumber;
-    }, z.core.$strip>>;
-    removeRequirementIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    removeRequirementIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type SystemDelta = z.infer<typeof SystemDelta>;
+/**
+ * NamespaceDelta - Declarative namespace transition.
+ *
+ * Patch paths are rooted at snapshot.namespaces[namespace].
+ */
+export declare const NamespaceDelta: z.ZodObject<{
+    namespace: z.ZodString;
+    patches: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"set">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"unset">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"merge">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "op">>;
+}, z.core.$strip>;
+export type NamespaceDelta = z.infer<typeof NamespaceDelta>;
 /**
  * ComputeResult - Result of compute() call
  */
@@ -79,6 +118,39 @@ export declare const ComputeResult: z.ZodObject<{
         }, z.core.$strip>], "kind">>;
         value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>], "op">>;
+    namespaceDelta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        patches: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"set">;
+            path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"prop">;
+                name: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"index">;
+                index: z.ZodNumber;
+            }, z.core.$strip>], "kind">>;
+            value: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"unset">;
+            path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"prop">;
+                name: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"index">;
+                index: z.ZodNumber;
+            }, z.core.$strip>], "kind">>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"merge">;
+            path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"prop">;
+                name: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"index">;
+                index: z.ZodNumber;
+            }, z.core.$strip>], "kind">>;
+            value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>], "op">>;
+    }, z.core.$strip>>>;
     systemDelta: z.ZodObject<{
         status: z.ZodOptional<z.ZodEnum<{
             error: "error";
@@ -97,7 +169,7 @@ export declare const ComputeResult: z.ZodObject<{
             timestamp: z.ZodNumber;
             context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>>;
-        addRequirements: z.ZodArray<z.ZodObject<{
+        addRequirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             type: z.ZodString;
             params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -107,8 +179,8 @@ export declare const ComputeResult: z.ZodObject<{
                 snapshotVersion: z.ZodNumber;
             }, z.core.$strip>;
             createdAt: z.ZodNumber;
-        }, z.core.$strip>>;
-        removeRequirementIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        removeRequirementIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     trace: z.ZodObject<{
         root: z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>;

package/dist/schema/snapshot.d.ts

@@ -80,12 +80,20 @@ export declare const SnapshotMeta: z.ZodObject<{
     schemaHash: z.ZodString;
 }, z.core.$strip>;
 export type SnapshotMeta = z.infer<typeof SnapshotMeta>;
+/**
+ * SnapshotNamespaces - Opaque platform/runtime/tooling namespaces.
+ *
+ * Core owns only the container contract. Namespace names and nested shapes are
+ * package-owned and must not be encoded in Core's canonical Snapshot type.
+ */
+export declare const SnapshotNamespaces: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type SnapshotNamespaces = z.infer<typeof SnapshotNamespaces>;
 /**
  * Snapshot - Immutable, point-in-time representation of world state.
  * This is the ONLY medium of communication between Core and Host.
  */
 export declare const Snapshot: z.ZodObject<{
-    data: z.ZodUnknown;
+    state: z.ZodUnknown;
     computed: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     system: z.ZodObject<{
         status: z.ZodEnum<{
@@ -124,9 +132,14 @@ export declare const Snapshot: z.ZodObject<{
         randomSeed: z.ZodString;
         schemaHash: z.ZodString;
     }, z.core.$strip>;
+    namespaces: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
 export type Snapshot = z.infer<typeof Snapshot>;
 /**
  * Create initial system state
  */
 export declare function createInitialSystemState(): SystemState;
+/**
+ * Create initial namespace container.
+ */
+export declare function createInitialNamespaces(): SnapshotNamespaces;

package/dist/schema/trace.d.ts

@@ -11,6 +11,8 @@ export declare const TraceNodeKind: z.ZodEnum<{
     call: "call";
     flow: "flow";
     halt: "halt";
+    namespaceRead: "namespaceRead";
+    namespaceDelta: "namespaceDelta";
     branch: "branch";
 }>;
 export type TraceNodeKind = z.infer<typeof TraceNodeKind>;

package/dist/utils/hash.d.ts

@@ -6,6 +6,10 @@ export type SchemaHashInput = {
     state: {
         fields: Record<string, unknown>;
     };
+    context?: {
+        fields: Record<string, unknown>;
+        fieldTypes?: Record<string, unknown>;
+    };
     computed: {
         fields: Record<string, {
             deps: string[];

package/dist/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from "./path.js";
 export * from "./canonical.js";
 export * from "./hash.js";
 export * from "./patch-path.js";
+export * from "./json-value.js";

package/dist/utils/json-value.d.ts

@@ -0,0 +1,26 @@
+/**
+ * JSON value-domain validation for snapshot/patch write boundaries.
+ *
+ * Manifesto state is required to be JSON-serializable and canonical
+ * (constitution §2.6 "Schema-first"). Values that JSON cannot represent
+ * must be rejected at the write boundary instead of being silently
+ * dropped or coerced later by canonicalization/hashing (#480).
+ *
+ * Accepted: null, string, boolean, finite number, arrays of accepted
+ * values, and plain objects (Object.prototype or null prototype) of
+ * accepted values.
+ *
+ * Notes:
+ * - -0 is accepted. JSON canonicalization normalizes it to 0, but
+ *   rejecting it would fail innocent arithmetic results (e.g. mul(0, -1)).
+ * - Shared (non-cyclic) references are accepted; JSON duplicates them.
+ */
+export type JsonValueViolation = {
+    readonly path: string;
+    readonly reason: string;
+};
+/**
+ * Returns the first JSON value-domain violation found in `value`, or null
+ * when the value is fully JSON-compatible. Pure and total: never throws.
+ */
+export declare function findJsonValueViolation(value: unknown, basePath?: string): JsonValueViolation | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manifesto-ai/core",
-  "version": "2.13.0",
+  "version": "5.1.0",
   "description": "Manifesto Core - Pure semantic calculator for deterministic state computation",
   "author": "eggplantiny <eggplantiny@gmail.com>",
   "license": "MIT",
@@ -41,14 +41,15 @@
     "typescript": "^5.9.3",
     "vite": "^8.0.8",
     "vitest": "^4.1.4",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@manifesto-ai/cts-kit": "5.0.0"
   },
   "scripts": {
     "build": "rm -rf dist && tsup && tsc -p tsconfig.build.json --emitDeclarationOnly --declarationMap false --outDir dist",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
-    "lint": "echo 'lint not configured'",
-    "test": "node ../../node_modules/vitest/vitest.mjs run",
-    "test:coverage": "node ../../node_modules/vitest/vitest.mjs run --coverage"
+    "lint": "node ../../node_modules/@biomejs/biome/bin/biome check src",
+    "test": "node ../../scripts/run-vitest.mjs run",
+    "test:coverage": "node ../../scripts/run-vitest.mjs run --coverage"
   }
 }

package/dist/schema/host-context.d.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-/**
- * HostContext - Explicit host-provided inputs for determinism
- */
-export declare const HostContext: z.ZodObject<{
-    now: z.ZodNumber;
-    randomSeed: z.ZodString;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    durationMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type HostContext = z.infer<typeof HostContext>;