@onereach/state-machine-core 1.0.0-framework.2

package/README.md

@@ -0,0 +1,3 @@
+# @onereach/state-machine-core
+
+This package defines the persisted format for State Machine templates and instances.

package/dist/index.d.mts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+//#region src/schemas/functions.d.ts
+declare const FunctionKindSchema: z.ZodEnum<{
+  query: "query";
+  mutation: "mutation";
+}>;
+type FunctionKind = z.infer<typeof FunctionKindSchema>;
+declare const FunctionImplementationSchema: z.ZodObject<{
+  runtime: z.ZodLiteral<"javascript">;
+  abi: z.ZodLiteral<"state-machine-function-v1">;
+  format: z.ZodLiteral<"async-function-body">;
+  code: z.ZodString;
+  capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const StateMachineFunctionDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  kind: z.ZodEnum<{
+    query: "query";
+    mutation: "mutation";
+  }>;
+  inputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+  }, z.core.$loose>;
+  outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  implementation: z.ZodObject<{
+    runtime: z.ZodLiteral<"javascript">;
+    abi: z.ZodLiteral<"state-machine-function-v1">;
+    format: z.ZodLiteral<"async-function-body">;
+    code: z.ZodString;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  annotations: z.ZodOptional<z.ZodObject<{
+    idempotent: z.ZodOptional<z.ZodBoolean>;
+    destructive: z.ZodOptional<z.ZodBoolean>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type StateMachineFunctionDefinition = z.infer<typeof StateMachineFunctionDefinitionSchema>;
+//#endregion
+//#region src/schemas/json-schema.d.ts
+declare const JsonSchemaSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type JsonSchema = z.infer<typeof JsonSchemaSchema>;
+declare const ObjectJsonSchemaSchema: z.ZodObject<{
+  type: z.ZodLiteral<"object">;
+}, z.core.$loose>;
+type ObjectJsonSchema = z.infer<typeof ObjectJsonSchemaSchema>;
+//#endregion
+//#region src/schemas/state-instance.d.ts
+declare const StateTemplateBindingSchema: z.ZodObject<{
+  id: z.ZodString;
+  version: z.ZodOptional<z.ZodString>;
+  revision: z.ZodString;
+}, z.core.$strip>;
+type StateTemplateBinding = z.infer<typeof StateTemplateBindingSchema>;
+declare const StateMachineInstanceSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  template: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    revision: z.ZodString;
+  }, z.core.$strip>;
+  state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  sequence: z.ZodNumber;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type StateMachineInstance = z.infer<typeof StateMachineInstanceSchema>;
+//#endregion
+//#region src/schemas/state-template.d.ts
+declare const StateTemplateSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  version: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  stateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+  }, z.core.$loose>;
+  initialState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  functions: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+      query: "query";
+      mutation: "mutation";
+    }>;
+    inputSchema: z.ZodObject<{
+      type: z.ZodLiteral<"object">;
+    }, z.core.$loose>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    implementation: z.ZodObject<{
+      runtime: z.ZodLiteral<"javascript">;
+      abi: z.ZodLiteral<"state-machine-function-v1">;
+      format: z.ZodLiteral<"async-function-body">;
+      code: z.ZodString;
+      capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    annotations: z.ZodOptional<z.ZodObject<{
+      idempotent: z.ZodOptional<z.ZodBoolean>;
+      destructive: z.ZodOptional<z.ZodBoolean>;
+      deprecated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type StateTemplateDefinition = z.infer<typeof StateTemplateSchema>;
+//#endregion
+//#region src/validation/types.d.ts
+interface SchemaValidationIssue {
+  /**
+   * JSON pointer / instance path.
+   *
+   * Example:
+   * /customer/id
+   */
+  path: string;
+  message?: string;
+  keyword?: string;
+  schemaPath?: string;
+  params?: unknown;
+}
+interface SchemaValidator<T = unknown> {
+  validate(value: unknown): value is T;
+  /**
+   * Issues from the most recent validate() call.
+   */
+  readonly issues: readonly SchemaValidationIssue[];
+}
+/**
+ * Lowest-level adapter interface.
+ *
+ * AJV, Zod, Valibot, or anything else only has to implement this.
+ */
+interface JsonSchemaValidatorCompiler {
+  compile<T = unknown>(schema: JsonSchema): SchemaValidator<T>;
+}
+interface CompiledFunctionValidators {
+  readonly input: SchemaValidator<Record<string, unknown>>;
+  readonly output?: SchemaValidator;
+}
+interface CompiledStateTemplateValidators {
+  readonly state: SchemaValidator<Record<string, unknown>>;
+  readonly functions: ReadonlyMap<string, CompiledFunctionValidators>;
+}
+type SchemaValidationTarget = 'initial-state' | 'input' | 'output' | 'state-before' | 'state-after';
+//#endregion
+//#region src/validation/compiler.d.ts
+declare class StateTemplateValidatorCompiler {
+  /**
+   * Same JSON Schema JS object -> same validator.
+   */
+  private readonly schemaCache;
+  /**
+   * Same parsed StateTemplate object -> same complete
+   * validator collection.
+   */
+  private readonly templateCache;
+  /**
+   * Immutable storage revision -> validator collection.
+   *
+   * This handles loading the same persisted template again,
+   * even though parsing produces a new JS object.
+   */
+  private readonly revisionCache;
+  /**
+   * Low-level schema compiler.
+   */
+  private readonly schemaCompiler;
+  constructor(schemaCompiler: JsonSchemaValidatorCompiler);
+  private compileSchema;
+  /**
+   * Get already-prepared validators by persistent revision key.
+   */
+  get(cacheKey: string): CompiledStateTemplateValidators | undefined;
+  /**
+   * Prepare validators for a template.
+   *
+   * Order:
+   *
+   * 1. revision cache
+   * 2. template object cache
+   * 3. actual schema compilation
+   */
+  compile(definition: StateTemplateDefinition, cacheKey?: string): CompiledStateTemplateValidators;
+  /**
+   * Associate validators that were already compiled with a
+   * persistent template revision.
+   *
+   * Critically, this performs NO compilation.
+   *
+   * This is primarily used by StateTemplateStore.save():
+   *
+   * compile definition
+   * → save definition
+   * → receive revision
+   * → bind revision to existing compiled validators
+   */
+  bind(cacheKey: string, validators: CompiledStateTemplateValidators): void;
+  invalidate(cacheKey: string): void;
+  clearRevisionCache(): void;
+}
+//#endregion
+//#region src/validation/errors.d.ts
+declare class SchemaValidationError extends Error {
+  readonly target: SchemaValidationTarget;
+  readonly errors: SchemaValidationIssue[] | null | undefined;
+  constructor(target: SchemaValidationTarget, errors: SchemaValidationIssue[] | null | undefined);
+}
+//#endregion
+//#region src/validation/validation.d.ts
+declare function assertSchema<T>(validator: SchemaValidator<T>, value: unknown, target: SchemaValidationTarget): asserts value is T;
+//#endregion
+export { type CompiledFunctionValidators, type CompiledStateTemplateValidators, FunctionImplementationSchema, FunctionKind, FunctionKindSchema, JsonSchema, JsonSchemaSchema, type JsonSchemaValidatorCompiler, ObjectJsonSchema, ObjectJsonSchemaSchema, SchemaValidationError, type SchemaValidationIssue, type SchemaValidationTarget, type SchemaValidator, StateMachineFunctionDefinition, StateMachineFunctionDefinitionSchema, StateMachineInstance, StateMachineInstanceSchema, StateTemplateBinding, StateTemplateBindingSchema, StateTemplateDefinition, StateTemplateSchema, StateTemplateValidatorCompiler, assertSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/schemas/functions.ts","../src/schemas/json-schema.ts","../src/schemas/state-instance.ts","../src/schemas/state-template.ts","../src/validation/types.ts","../src/validation/compiler.ts","../src/validation/errors.ts","../src/validation/validation.ts"],"mappings":";;cAIa,oBAAkB,EAAA;;;;KAEnB,eAAe,EAAE,aAAa;cAE7B,8BAA4B,EAAA;;;;;;;GAsCvC,EAAA,KAAA;cAEW,sCAAoC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GA8B/C,EAAA,KAAA;KAEU,iCAAiC,EAAE,aAAa;;;cC9E/C,kBAAgB,EAAA,UAAA,EAAA,WAAA,EAAA;KAEjB,aAAa,EAAE,aAAa;cAE3B,wBAAsB,EAAA;;GAEjC,EAAA,KAAA;KAEU,mBAAmB,EAAE,aAAa;;;cCRjC,4BAA0B,EAAA;;;;GAsBrC,EAAA,KAAA;KAEU,uBAAuB,EAAE,aAAa;cAErC,4BAA0B,EAAA;;;;;;;;;;;;;GA0CrC,EAAA,KAAA;KAEU,uBAAuB,EAAE,aAAa;;;cCnErC,qBAAmB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6C5B,EAAA,KAAA;KAEQ,0BAA0B,EAAE,aAAa;;;UClDpC;;;;;;;EAOf;EAEA;EAEA;EAEA;EAEA;;UAGe,gBAAgB;EAC/B,SAAS,iBAAiB,SAAS;;;;WAK1B,iBAAiB;;;;;;;UAQX;EACf,QAAQ,aAAa,QAAQ,aAAa,gBAAgB;;UAa3C;WACN,OAAO,gBAAgB;WAEvB,SAAS;;UAGH;WACN,OAAO,gBAAgB;WAEvB,WAAW,oBAAoB;;KAa9B;;;cCzDC;;;;mBAIM;;;;;mBAMA;;;;;;;mBAQA;;;;mBAKA;EAEL,YAAA,gBAAgB;UAIpB;;;;EAgBD,IAAI,mBAAmB;;;;;;;;;;EAavB,QAAQ,YAAY,yBAAyB,oBAAoB;;;;;;;;;;;;;;EA8DjE,KAAK,kBAAkB,YAAY;EAInC,WAAW;EAIX;;;;cC3II,8BAA8B;WACzB,QAAQ;WACR,QAAQ;EAEZ,YAAA,QAAQ,wBAAwB,QAAQ;;;;iBCOtC,aAAa,GAC3B,WAAW,gBAAgB,IAC3B,gBACA,QAAQ,iCACC,SAAS"}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{z as e}from"zod";const t=e.record(e.string(),e.unknown()),n=e.looseObject({type:e.literal(`object`)}),r=e.enum([`query`,`mutation`]),i=e.object({runtime:e.literal(`javascript`),abi:e.literal(`state-machine-function-v1`),format:e.literal(`async-function-body`),code:e.string().min(1),capabilities:e.array(e.string()).default([]),timeoutMs:e.number().int().positive().optional()}),a=e.object({name:e.string().min(1),description:e.string().optional(),kind:r,inputSchema:n,outputSchema:t.optional(),implementation:i,annotations:e.object({idempotent:e.boolean().optional(),destructive:e.boolean().optional(),deprecated:e.boolean().optional()}).optional(),metadata:e.record(e.string(),e.unknown()).optional()}),o=e.object({id:e.string().min(1),version:e.string().optional(),revision:e.string().min(1)}),s=e.object({schemaVersion:e.literal(1),id:e.string().min(1),template:o,state:e.record(e.string(),e.unknown()),sequence:e.number().int().nonnegative(),createdAt:e.iso.datetime(),updatedAt:e.iso.datetime(),metadata:e.record(e.string(),e.unknown()).optional()}),c=e.object({schemaVersion:e.literal(1),id:e.string().min(1),version:e.string().optional(),description:e.string().optional(),stateSchema:n,initialState:e.record(e.string(),e.unknown()),functions:e.array(a),metadata:e.record(e.string(),e.unknown()).optional()}).superRefine((e,t)=>{let n=new Set;for(let[r,i]of e.functions.entries())n.has(i.name)&&t.addIssue({code:`custom`,path:[`functions`,r,`name`],message:`Duplicate function name: ${i.name}`}),n.add(i.name)});var l=class extends Error{target;errors;constructor(e,t){super(`Schema validation failed: ${e}`),this.name=`SchemaValidationError`,this.target=e,this.errors=t}};function u(e,t,n){if(!e.validate(t))throw new l(n,[...e.issues])}var d=class{schemaCache=new WeakMap;templateCache=new WeakMap;revisionCache=new Map;schemaCompiler;constructor(e){this.schemaCompiler=e}compileSchema(e){let t=e,n=this.schemaCache.get(t);if(n)return n;let r=this.schemaCompiler.compile(e);return this.schemaCache.set(t,r),r}get(e){return this.revisionCache.get(e)}compile(e,t){if(t){let e=this.revisionCache.get(t);if(e)return e}let n=this.templateCache.get(e);if(n)return t&&this.bind(t,n),n;let r=this.compileSchema(e.stateSchema);u(r,e.initialState,`initial-state`);let i=new Map;for(let t of e.functions)i.set(t.name,{input:this.compileSchema(t.inputSchema),output:t.outputSchema?this.compileSchema(t.outputSchema):void 0});let a={state:r,functions:i};return this.templateCache.set(e,a),t&&this.bind(t,a),a}bind(e,t){this.revisionCache.set(e,t)}invalidate(e){this.revisionCache.delete(e)}clearRevisionCache(){this.revisionCache.clear()}};export{i as FunctionImplementationSchema,r as FunctionKindSchema,t as JsonSchemaSchema,n as ObjectJsonSchemaSchema,l as SchemaValidationError,a as StateMachineFunctionDefinitionSchema,s as StateMachineInstanceSchema,o as StateTemplateBindingSchema,c as StateTemplateSchema,d as StateTemplateValidatorCompiler,u as assertSchema};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/schemas/json-schema.ts","../src/schemas/functions.ts","../src/schemas/state-instance.ts","../src/schemas/state-template.ts","../src/validation/errors.ts","../src/validation/validation.ts","../src/validation/compiler.ts"],"sourcesContent":["import { z } from 'zod';\n\nexport const JsonSchemaSchema = z.record(z.string(), z.unknown());\n\nexport type JsonSchema = z.infer<typeof JsonSchemaSchema>;\n\nexport const ObjectJsonSchemaSchema = z.looseObject({\n  type: z.literal('object'),\n});\n\nexport type ObjectJsonSchema = z.infer<typeof ObjectJsonSchemaSchema>;\n","import { z } from 'zod';\n\nimport { JsonSchemaSchema, ObjectJsonSchemaSchema } from './json-schema.ts';\n\nexport const FunctionKindSchema = z.enum(['query', 'mutation']);\n\nexport type FunctionKind = z.infer<typeof FunctionKindSchema>;\n\nexport const FunctionImplementationSchema = z.object({\n  runtime: z.literal('javascript'),\n\n  /**\n   * ABI v1 means:\n   *\n   * ```javascript\n   * async function(input, state, ctx) {\n   *   // implementation.code\n   * }\n   * ```\n   */\n  abi: z.literal('state-machine-function-v1'),\n\n  format: z.literal('async-function-body'),\n\n  /**\n   * JavaScript function BODY.\n   *\n   * Not:\n   *\n   * ```javascript\n   * async function(...) {}\n   * ```\n   *\n   * But:\n   *\n   * ```javascript\n   * const x = await ctx.foo(...)\n   * state.foo = x\n   * return x\n   * ```\n   */\n  code: z.string().min(1),\n\n  capabilities: z.array(z.string()).default([]),\n\n  timeoutMs: z.number().int().positive().optional(),\n});\n\nexport const StateMachineFunctionDefinitionSchema = z.object({\n  name: z.string().min(1),\n\n  description: z.string().optional(),\n\n  kind: FunctionKindSchema,\n\n  /**\n   * Argument #1.\n   */\n  inputSchema: ObjectJsonSchemaSchema,\n\n  /**\n   * Return value.\n   */\n  outputSchema: JsonSchemaSchema.optional(),\n\n  implementation: FunctionImplementationSchema,\n\n  annotations: z\n    .object({\n      idempotent: z.boolean().optional(),\n\n      destructive: z.boolean().optional(),\n\n      deprecated: z.boolean().optional(),\n    })\n    .optional(),\n\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type StateMachineFunctionDefinition = z.infer<typeof StateMachineFunctionDefinitionSchema>;\n","import { z } from 'zod';\n\nexport const StateTemplateBindingSchema = z.object({\n  /**\n   * The unique identifier of the template.\n   */\n  id: z.string().min(1),\n\n  /**\n   * The version of the template.\n   *\n   * Optional because the template may not have a version.\n   */\n  version: z.string().optional(),\n\n  /**\n   * Driver-level revision of the template that this\n   * instance was created against.\n   *\n   * This prevents an instance silently starting to\n   * execute a different template after the template\n   * file/object changes.\n   */\n  revision: z.string().min(1),\n});\n\nexport type StateTemplateBinding = z.infer<typeof StateTemplateBindingSchema>;\n\nexport const StateMachineInstanceSchema = z.object({\n  /**\n   * The schema version of the instance.\n   */\n  schemaVersion: z.literal(1),\n\n  /**\n   * The unique identifier of the instance.\n   */\n  id: z.string().min(1),\n\n  /**\n   * The template binding of the instance.\n   */\n  template: StateTemplateBindingSchema,\n\n  /**\n   * The state of the instance.\n   */\n  state: z.record(z.string(), z.unknown()),\n\n  /**\n   * Logical instance version.\n   *\n   * Increased for every successful persisted update.\n   */\n  sequence: z.number().int().nonnegative(),\n\n  /**\n   * The date and time the instance was created.\n   */\n  createdAt: z.iso.datetime(),\n\n  /**\n   * The date and time the instance was last updated.\n   */\n  updatedAt: z.iso.datetime(),\n\n  /**\n   * Additional metadata about the instance.\n   */\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type StateMachineInstance = z.infer<typeof StateMachineInstanceSchema>;\n","import { z } from 'zod';\n\nimport { StateMachineFunctionDefinitionSchema } from './functions.ts';\nimport { ObjectJsonSchemaSchema } from './json-schema.ts';\n\nexport const StateTemplateSchema = z\n  .object({\n    schemaVersion: z.literal(1),\n\n    id: z.string().min(1),\n\n    /**\n     * Logical/app version.\n     *\n     * This is different from a storage-driver revision.\n     */\n    version: z.string().optional(),\n\n    description: z.string().optional(),\n\n    /**\n     * Schema shared by every function in this machine.\n     */\n    stateSchema: ObjectJsonSchemaSchema,\n\n    /**\n     * Used when creating a new state-machine instance.\n     */\n    initialState: z.record(z.string(), z.unknown()),\n\n    functions: z.array(StateMachineFunctionDefinitionSchema),\n\n    metadata: z.record(z.string(), z.unknown()).optional(),\n  })\n  .superRefine((template, context) => {\n    const names = new Set<string>();\n\n    for (const [index, function_] of template.functions.entries()) {\n      if (names.has(function_.name)) {\n        context.addIssue({\n          code: 'custom',\n\n          path: ['functions', index, 'name'],\n\n          message: `Duplicate function name: ${function_.name}`,\n        });\n      }\n\n      names.add(function_.name);\n    }\n  });\n\nexport type StateTemplateDefinition = z.infer<typeof StateTemplateSchema>;\n","import type { SchemaValidationIssue, SchemaValidationTarget } from './types.ts';\n\nexport class SchemaValidationError extends Error {\n  public readonly target: SchemaValidationTarget;\n  public readonly errors: SchemaValidationIssue[] | null | undefined;\n\n  constructor(target: SchemaValidationTarget, errors: SchemaValidationIssue[] | null | undefined) {\n    super(`Schema validation failed: ${target}`);\n\n    this.name = 'SchemaValidationError';\n    this.target = target;\n    this.errors = errors;\n  }\n}\n","import { SchemaValidationError } from './errors.ts';\nimport type { SchemaValidationTarget, SchemaValidator } from './types.ts';\n\n/*\n--------------------------------------------------------------------------\n*/\n/*\nGeneric validator\n*/\n/*\n--------------------------------------------------------------------------\n*/\n\nexport function assertSchema<T>(\n  validator: SchemaValidator<T>,\n  value: unknown,\n  target: SchemaValidationTarget,\n): asserts value is T {\n  if (validator.validate(value)) return;\n\n  throw new SchemaValidationError(target, [...validator.issues]);\n}\n","// state-machine-core/src/validation/compiler.ts\n\nimport type { JsonSchema } from '../schemas/json-schema.ts';\nimport type { StateTemplateDefinition } from '../schemas/state-template.ts';\n\nimport type {\n  JsonSchemaValidatorCompiler,\n  SchemaValidator,\n  CompiledFunctionValidators,\n  CompiledStateTemplateValidators,\n} from './types.js';\nimport { assertSchema } from './validation.ts';\n\nexport class StateTemplateValidatorCompiler {\n  /**\n   * Same JSON Schema JS object -> same validator.\n   */\n  private readonly schemaCache = new WeakMap<object, SchemaValidator>();\n\n  /**\n   * Same parsed StateTemplate object -> same complete\n   * validator collection.\n   */\n  private readonly templateCache = new WeakMap<StateTemplateDefinition, CompiledStateTemplateValidators>();\n\n  /**\n   * Immutable storage revision -> validator collection.\n   *\n   * This handles loading the same persisted template again,\n   * even though parsing produces a new JS object.\n   */\n  private readonly revisionCache = new Map<string, CompiledStateTemplateValidators>();\n\n  /**\n   * Low-level schema compiler.\n   */\n  private readonly schemaCompiler: JsonSchemaValidatorCompiler;\n\n  constructor(schemaCompiler: JsonSchemaValidatorCompiler) {\n    this.schemaCompiler = schemaCompiler;\n  }\n\n  private compileSchema<T>(schema: JsonSchema): SchemaValidator<T> {\n    const object = schema as object;\n    const cached = this.schemaCache.get(object);\n\n    if (cached) return cached as SchemaValidator<T>;\n\n    const validator = this.schemaCompiler.compile<T>(schema);\n\n    this.schemaCache.set(object, validator);\n\n    return validator;\n  }\n\n  /**\n   * Get already-prepared validators by persistent revision key.\n   */\n  public get(cacheKey: string): CompiledStateTemplateValidators | undefined {\n    return this.revisionCache.get(cacheKey);\n  }\n\n  /**\n   * Prepare validators for a template.\n   *\n   * Order:\n   *\n   * 1. revision cache\n   * 2. template object cache\n   * 3. actual schema compilation\n   */\n  public compile(definition: StateTemplateDefinition, cacheKey?: string): CompiledStateTemplateValidators {\n    /*\n     * Same persisted template revision.\n     */\n    if (cacheKey) {\n      const cached = this.revisionCache.get(cacheKey);\n      if (cached) return cached;\n    }\n\n    /*\n     * Same parsed template object.\n     */\n    const objectCached = this.templateCache.get(definition);\n\n    if (objectCached) {\n      if (cacheKey) this.bind(cacheKey, objectCached);\n      return objectCached;\n    }\n\n    const state = this.compileSchema<Record<string, unknown>>(definition.stateSchema);\n\n    /*\n     * initialState is part of template validity, so reject\n     * the template immediately rather than waiting for an\n     * instance to be created.\n     */\n    assertSchema(state, definition.initialState, 'initial-state');\n\n    const functions = new Map<string, CompiledFunctionValidators>();\n\n    for (const function_ of definition.functions) {\n      functions.set(function_.name, {\n        input: this.compileSchema<Record<string, unknown>>(function_.inputSchema),\n        output: function_.outputSchema ? this.compileSchema(function_.outputSchema) : undefined,\n      });\n    }\n\n    const compiled: CompiledStateTemplateValidators = {\n      state,\n      functions,\n    };\n\n    this.templateCache.set(definition, compiled);\n\n    if (cacheKey) this.bind(cacheKey, compiled);\n\n    return compiled;\n  }\n\n  /**\n   * Associate validators that were already compiled with a\n   * persistent template revision.\n   *\n   * Critically, this performs NO compilation.\n   *\n   * This is primarily used by StateTemplateStore.save():\n   *\n   * compile definition\n   * → save definition\n   * → receive revision\n   * → bind revision to existing compiled validators\n   */\n  public bind(cacheKey: string, validators: CompiledStateTemplateValidators): void {\n    this.revisionCache.set(cacheKey, validators);\n  }\n\n  public invalidate(cacheKey: string): void {\n    this.revisionCache.delete(cacheKey);\n  }\n\n  public clearRevisionCache(): void {\n    this.revisionCache.clear();\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@onereach/state-machine-core",
+  "version": "1.0.0-framework.2",
+  "description": "State Machine persisted format specification",
+  "keywords": [
+    "onereach",
+    "toolkit",
+    "state-machine"
+  ],
+  "author": "OneReach Development Team <dev.team@onereach.ai>",
+  "license": "Apache-2.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!dist/metafile*.json"
+  ],
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.5",
+    "@types/source-map-support": "^0.5.10",
+    "publint": "^0.3.24",
+    "rollup-plugin-visualizer": "^7.1.1",
+    "tsdown": "^0.22.14",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "zod": "^4.5.4"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.mts",
+    "build:visualize": "VISUALIZE=1 pnpm build",
+    "typecheck": "tsc --noEmit",
+    "preversion_": "pnpm build && pnpm test",
+    "publish:rc": "pnpm version prerelease --preid rc && pnpm publish --tag rc",
+    "test": "pnpm run unit",
+    "unit": "vitest run",
+    "preversion": "pnpm build"
+  }
+}