@manifesto-ai/sdk 1.2.0 → 2.0.0

package/dist/index.js

@@ -1,49 +1,588 @@
-/**
- * @manifesto-ai/sdk v1.0.0
- *
- * Public developer API layer for the Manifesto protocol stack.
- * Canonical entry point since Phase 2 (ADR-008).
- *
- * @see sdk-SPEC-v0.1.0.md
- * @packageDocumentation
- */
-// =============================================================================
-// Public Errors (re-exported from Runtime)
-// =============================================================================
-export { 
-// Base
-ManifestoAppError, 
-// Lifecycle
-AppNotReadyError, AppDisposedError, 
-// Action
-ActionRejectedError, ActionFailedError, ActionPreparationError, ActionTimeoutError, ActionNotFoundError, HandleDetachedError, 
-// Hook
-HookMutationError, 
-// Effects
-ReservedEffectTypeError, 
-// System
-SystemActionDisabledError, SystemActionRoutingError, 
-// Memory
-MemoryDisabledError, 
-// Branch/World
-BranchNotFoundError, WorldNotFoundError, WorldSchemaHashMismatchError, WorldNotInLineageError, 
-// Other
-ReservedNamespaceError, MissingDefaultActorError, DomainCompileError, PluginInitError, 
-// Resume & Recovery
-SchemaMismatchOnResumeError, BranchHeadNotFoundError, } from '@manifesto-ai/runtime';
-// =============================================================================
-// App Factory
-// =============================================================================
-export { createApp, createTestApp } from './create-app.js';
-// =============================================================================
-// ManifestoApp
-// =============================================================================
-export { ManifestoApp } from './app.js';
-// =============================================================================
-// Hook Internals (public for advanced integrations)
-// =============================================================================
-export { AppRefImpl, createAppRef } from './hooks/index.js';
-export { HookableImpl } from './hooks/index.js';
-export { JobQueue } from './hooks/index.js';
-export { HookContextImpl, createHookContext } from './hooks/index.js';
+// src/create-manifesto.ts
+import {
+  createHost
+} from "@manifesto-ai/host";
+import {
+  semanticPathToPatchPath,
+  extractDefaults
+} from "@manifesto-ai/core";
+import { compileMelDomain } from "@manifesto-ai/compiler";
+
+// src/errors.ts
+var ManifestoError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ManifestoError";
+    this.code = code;
+  }
+};
+var ReservedEffectError = class extends ManifestoError {
+  effectType;
+  constructor(effectType) {
+    super(
+      "RESERVED_EFFECT",
+      `Effect type "${effectType}" is reserved and cannot be overridden`
+    );
+    this.name = "ReservedEffectError";
+    this.effectType = effectType;
+  }
+};
+var CompileError = class extends ManifestoError {
+  diagnostics;
+  constructor(diagnostics, formattedMessage) {
+    super("COMPILE_ERROR", formattedMessage);
+    this.name = "CompileError";
+    this.diagnostics = diagnostics;
+  }
+};
+var DisposedError = class extends ManifestoError {
+  constructor() {
+    super("DISPOSED", "Cannot dispatch on a disposed ManifestoInstance");
+    this.name = "DisposedError";
+  }
+};
+
+// src/create-manifesto.ts
+var RESERVED_EFFECT_TYPE = "system.get";
+var RESERVED_NAMESPACE_PREFIX = "system.";
+function createManifesto(config) {
+  const schema = resolveSchema(config.schema);
+  if (RESERVED_EFFECT_TYPE in config.effects) {
+    throw new ReservedEffectError(RESERVED_EFFECT_TYPE);
+  }
+  validateReservedNamespaces(schema);
+  const host = createInternalHost(schema, config.effects, config.snapshot);
+  let currentSnapshot = host.getSnapshot();
+  const subscribers = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Map();
+  let dispatchQueue = Promise.resolve();
+  let disposed = false;
+  const guard = config.guard ?? null;
+  function dispatch(intent) {
+    if (disposed) {
+      throw new DisposedError();
+    }
+    const enrichedIntent = intent.intentId ? intent : { ...intent, intentId: generateIntentId() };
+    const prev = dispatchQueue;
+    dispatchQueue = prev.catch(() => {
+    }).then(() => processIntent(enrichedIntent));
+    dispatchQueue = dispatchQueue.catch(() => {
+    });
+  }
+  async function processIntent(intent) {
+    if (disposed) return;
+    if (guard) {
+      try {
+        const allowed = guard(intent, Object.freeze(structuredClone(currentSnapshot)));
+        if (!allowed) {
+          emitEvent("dispatch:rejected", {
+            intentId: intent.intentId,
+            intent,
+            reason: "Guard rejected the intent"
+          });
+          return;
+        }
+      } catch (error) {
+        emitEvent("dispatch:failed", {
+          intentId: intent.intentId,
+          intent,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+        return;
+      }
+    }
+    try {
+      const result = await host.dispatch(intent);
+      if (result.status === "error") {
+        currentSnapshot = result.snapshot;
+        notifySubscribers();
+        emitEvent("dispatch:failed", {
+          intentId: intent.intentId,
+          intent,
+          error: result.error ?? new ManifestoError("HOST_ERROR", "Host dispatch failed")
+        });
+        return;
+      }
+      currentSnapshot = result.snapshot;
+      notifySubscribers();
+      emitEvent("dispatch:completed", {
+        intentId: intent.intentId,
+        intent,
+        snapshot: result.snapshot
+      });
+    } catch (error) {
+      emitEvent("dispatch:failed", {
+        intentId: intent.intentId,
+        intent,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  function subscribe(selector, listener) {
+    if (disposed) return () => {
+    };
+    const sub = {
+      selector,
+      listener,
+      lastValue: selector(currentSnapshot),
+      initialized: true
+    };
+    subscribers.add(sub);
+    return () => {
+      subscribers.delete(sub);
+    };
+  }
+  function on(event, handler) {
+    if (disposed) return () => {
+    };
+    let listeners = eventListeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      eventListeners.set(event, listeners);
+    }
+    listeners.add(handler);
+    return () => {
+      listeners.delete(handler);
+    };
+  }
+  function getSnapshot() {
+    return Object.freeze(structuredClone(currentSnapshot));
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    subscribers.clear();
+    eventListeners.clear();
+  }
+  function notifySubscribers() {
+    const frozenSnap = Object.freeze(structuredClone(currentSnapshot));
+    for (const sub of subscribers) {
+      const selected = sub.selector(frozenSnap);
+      if (sub.initialized && Object.is(sub.lastValue, selected)) {
+        continue;
+      }
+      sub.lastValue = selected;
+      sub.initialized = true;
+      sub.listener(selected);
+    }
+  }
+  function emitEvent(event, payload) {
+    const listeners = eventListeners.get(event);
+    if (!listeners) return;
+    for (const handler of listeners) {
+      try {
+        handler(payload);
+      } catch {
+      }
+    }
+  }
+  return { dispatch, subscribe, on, getSnapshot, dispose };
+}
+function resolveSchema(schema) {
+  let domainSchema;
+  if (typeof schema === "string") {
+    const result = compileMelDomain(schema, { mode: "domain" });
+    if (result.errors.length > 0) {
+      const formatted = result.errors.map((d) => {
+        const loc = d.location;
+        const header = loc && (loc.start.line > 0 || loc.start.column > 0) ? `[${d.code}] ${d.message} (${loc.start.line}:${loc.start.column})` : `[${d.code}] ${d.message}`;
+        if (!loc || loc.start.line === 0) return header;
+        const sourceLines = schema.split("\n");
+        const lineContent = sourceLines[loc.start.line - 1];
+        if (!lineContent) return header;
+        const lineNumStr = String(loc.start.line).padStart(4, " ");
+        const underlineLen = Math.max(
+          1,
+          loc.end.line === loc.start.line ? Math.min(loc.end.column - loc.start.column, lineContent.length - loc.start.column + 1) : 1
+        );
+        const padding = " ".repeat(lineNumStr.length + 3 + loc.start.column - 1);
+        return `${header}
+${lineNumStr} | ${lineContent}
+${padding}${"^".repeat(underlineLen)}`;
+      }).join("\n\n");
+      throw new CompileError(
+        result.errors,
+        `MEL compilation failed:
+${formatted}`
+      );
+    }
+    if (!result.schema) {
+      throw new ManifestoError(
+        "COMPILE_ERROR",
+        "MEL compilation produced no schema"
+      );
+    }
+    domainSchema = result.schema;
+  } else {
+    domainSchema = schema;
+  }
+  return withPlatformNamespaces(domainSchema);
+}
+function withPlatformNamespaces(schema) {
+  const fields = { ...schema.state.fields };
+  let changed = false;
+  if (!fields.$host) {
+    fields.$host = {
+      type: "object",
+      required: false,
+      default: {}
+    };
+    changed = true;
+  } else if (fields.$host.type !== "object") {
+    throw new ManifestoError(
+      "SCHEMA_ERROR",
+      "Reserved namespace '$host' must be an object field"
+    );
+  } else if (fields.$host.default === void 0) {
+    fields.$host = { ...fields.$host, default: {} };
+    changed = true;
+  }
+  if (!fields.$mel) {
+    fields.$mel = {
+      type: "object",
+      required: false,
+      default: { guards: { intent: {} } },
+      fields: {
+        guards: {
+          type: "object",
+          required: false,
+          default: { intent: {} },
+          fields: {
+            intent: {
+              type: "object",
+              required: false,
+              default: {}
+            }
+          }
+        }
+      }
+    };
+    changed = true;
+  } else if (fields.$mel.type !== "object") {
+    throw new ManifestoError(
+      "SCHEMA_ERROR",
+      "Reserved namespace '$mel' must be an object field"
+    );
+  } else {
+    let nextMel = fields.$mel;
+    if (nextMel.default === void 0) {
+      nextMel = { ...nextMel, default: { guards: { intent: {} } } };
+      changed = true;
+    }
+    const melFields = nextMel.fields ?? {};
+    const guardsField = melFields.guards;
+    if (!guardsField) {
+      nextMel = {
+        ...nextMel,
+        fields: {
+          ...melFields,
+          guards: {
+            type: "object",
+            required: false,
+            default: { intent: {} },
+            fields: {
+              intent: {
+                type: "object",
+                required: false,
+                default: {}
+              }
+            }
+          }
+        }
+      };
+      changed = true;
+    } else if (guardsField.type !== "object") {
+      throw new ManifestoError(
+        "SCHEMA_ERROR",
+        "Reserved namespace '$mel.guards' must be an object field"
+      );
+    } else {
+      let nextGuards = guardsField;
+      if (guardsField.default === void 0) {
+        nextGuards = { ...nextGuards, default: { intent: {} } };
+        changed = true;
+      }
+      const guardFields = nextGuards.fields ?? {};
+      const intentField = guardFields.intent;
+      if (!intentField) {
+        nextGuards = {
+          ...nextGuards,
+          fields: {
+            ...guardFields,
+            intent: {
+              type: "object",
+              required: false,
+              default: {}
+            }
+          }
+        };
+        changed = true;
+      } else if (intentField.type !== "object") {
+        throw new ManifestoError(
+          "SCHEMA_ERROR",
+          "Reserved namespace '$mel.guards.intent' must be an object field"
+        );
+      } else if (intentField.default === void 0) {
+        nextGuards = {
+          ...nextGuards,
+          fields: {
+            ...guardFields,
+            intent: { ...intentField, default: {} }
+          }
+        };
+        changed = true;
+      }
+      if (nextGuards !== guardsField) {
+        nextMel = {
+          ...nextMel,
+          fields: {
+            ...melFields,
+            guards: nextGuards
+          }
+        };
+      }
+    }
+    if (nextMel !== fields.$mel) {
+      fields.$mel = nextMel;
+      changed = true;
+    }
+  }
+  if (!changed) return schema;
+  return {
+    ...schema,
+    state: {
+      ...schema.state,
+      fields
+    }
+  };
+}
+function validateReservedNamespaces(schema) {
+  const actions = schema.actions || {};
+  for (const actionType of Object.keys(actions)) {
+    if (actionType.startsWith(RESERVED_NAMESPACE_PREFIX)) {
+      throw new ManifestoError(
+        "RESERVED_NAMESPACE",
+        `Action type "${actionType}" uses reserved namespace prefix "${RESERVED_NAMESPACE_PREFIX}"`
+      );
+    }
+  }
+}
+function createInternalHost(schema, effects, initialSnapshot) {
+  const host = createHost(schema, {
+    initialData: initialSnapshot?.data ?? extractDefaults(schema.state)
+  });
+  if (initialSnapshot) {
+    host.reset(initialSnapshot);
+  }
+  host.registerEffect(RESERVED_EFFECT_TYPE, async (_type, params, ctx) => {
+    const { patches } = executeSystemGet(params, ctx.snapshot);
+    return patches;
+  });
+  for (const [effectType, appHandler] of Object.entries(effects)) {
+    const hostHandler = async (_type, params, ctx) => {
+      const appCtx = { snapshot: ctx.snapshot };
+      const patches = await appHandler(params, appCtx);
+      return patches;
+    };
+    host.registerEffect(effectType, hostHandler);
+  }
+  return host;
+}
+function isGenerateParams(params) {
+  return typeof params === "object" && params !== null && "key" in params && "into" in params;
+}
+function generateSystemValue(key) {
+  switch (key) {
+    case "uuid":
+      return generateUUID();
+    case "timestamp":
+    case "time.now":
+      return Date.now();
+    case "isoTimestamp":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    default:
+      return null;
+  }
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function executeSystemGet(params, snapshot) {
+  if (isGenerateParams(params)) {
+    const value = generateSystemValue(params.key);
+    const patches2 = [{
+      op: "set",
+      path: normalizeTargetPath(params.into),
+      value
+    }];
+    return { patches: patches2 };
+  }
+  const { path, target } = params;
+  const result = resolvePathValue(path, snapshot);
+  const patches = [];
+  if (target) {
+    patches.push({
+      op: "set",
+      path: normalizeTargetPath(target),
+      value: result.value
+    });
+  }
+  return { patches };
+}
+function normalizePath(path) {
+  if (path.startsWith("/")) {
+    return path.slice(1).replace(/\//g, ".");
+  }
+  return path;
+}
+function normalizeTargetPath(path) {
+  const normalized = normalizePath(path);
+  const withoutDataRoot = normalized.startsWith("data.") ? normalized.slice("data.".length) : normalized;
+  return semanticPathToPatchPath(withoutDataRoot);
+}
+function resolvePathValue(path, snapshot) {
+  const normalized = normalizePath(path);
+  const parts = normalized.split(".");
+  if (parts.length === 0) {
+    return { value: void 0, found: false };
+  }
+  const root = parts[0];
+  const rest = parts.slice(1);
+  let current;
+  switch (root) {
+    case "data":
+      current = snapshot.data;
+      break;
+    case "computed":
+      current = snapshot.computed;
+      break;
+    case "system":
+      current = snapshot.system;
+      break;
+    case "meta":
+      current = snapshot.meta;
+      break;
+    default:
+      current = snapshot.data;
+      rest.unshift(root);
+  }
+  for (const part of rest) {
+    if (current === null || current === void 0) {
+      return { value: void 0, found: false };
+    }
+    if (typeof current !== "object") {
+      return { value: void 0, found: false };
+    }
+    current = current[part];
+  }
+  return { value: current, found: current !== void 0 };
+}
+function generateIntentId() {
+  return generateUUID();
+}
+
+// src/dispatch-async.ts
+var DispatchRejectedError = class extends Error {
+  code = "DISPATCH_REJECTED";
+  intentId;
+  constructor(intentId, reason) {
+    super(reason ?? "Intent was rejected by guard");
+    this.name = "DispatchRejectedError";
+    this.intentId = intentId;
+  }
+};
+function dispatchAsync(instance, intent) {
+  const intentId = intent.intentId ?? generateId();
+  const enriched = intent.intentId ? intent : { ...intent, intentId };
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      unsubCompleted();
+      unsubFailed();
+      unsubRejected();
+    };
+    const unsubCompleted = instance.on("dispatch:completed", (e) => {
+      if (e.intentId === intentId) {
+        cleanup();
+        resolve(e.snapshot);
+      }
+    });
+    const unsubFailed = instance.on("dispatch:failed", (e) => {
+      if (e.intentId === intentId) {
+        cleanup();
+        reject(e.error ?? new Error("Dispatch failed"));
+      }
+    });
+    const unsubRejected = instance.on("dispatch:rejected", (e) => {
+      if (e.intentId === intentId) {
+        cleanup();
+        reject(new DispatchRejectedError(intentId, e.reason));
+      }
+    });
+    instance.dispatch(enriched);
+  });
+}
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/typed-ops.ts
+import { semanticPathToPatchPath as semanticPathToPatchPath2 } from "@manifesto-ai/core";
+function defineOps() {
+  const toPatchPath = (path) => semanticPathToPatchPath2(path);
+  return {
+    set(path, value) {
+      return { op: "set", path: toPatchPath(path), value };
+    },
+    unset(path) {
+      return { op: "unset", path: toPatchPath(path) };
+    },
+    merge(path, value) {
+      return { op: "merge", path: toPatchPath(path), value };
+    },
+    raw: {
+      set(path, value) {
+        return { op: "set", path: toPatchPath(path), value };
+      },
+      unset(path) {
+        return { op: "unset", path: toPatchPath(path) };
+      },
+      merge(path, value) {
+        return { op: "merge", path: toPatchPath(path), value };
+      }
+    }
+  };
+}
+
+// src/index.ts
+import { createIntent, createSnapshot, createCore } from "@manifesto-ai/core";
+import { createMemoryWorldStore } from "@manifesto-ai/world";
+export {
+  CompileError,
+  DispatchRejectedError,
+  DisposedError,
+  ManifestoError,
+  ReservedEffectError,
+  createCore,
+  createIntent,
+  createManifesto,
+  createMemoryWorldStore,
+  createSnapshot,
+  defineOps,
+  dispatchAsync
+};
 //# sourceMappingURL=index.js.map