@manifesto-ai/sdk 2.3.0 → 3.1.1

package/dist/index.js

@@ -1,240 +1,113 @@
+import {
+  ACTION_PARAM_NAMES,
+  AlreadyActivatedError,
+  CompileError,
+  DisposedError,
+  ManifestoError,
+  ReservedEffectError,
+  activateComposable,
+  attachRuntimeKernelFactory,
+  createBaseRuntimeInstance,
+  createRuntimeKernel
+} from "./chunk-NGW654NU.js";
+
 // src/create-manifesto.ts
 import {
   createHost
 } from "@manifesto-ai/host";
 import {
-  getAvailableActions as queryAvailableActions,
-  isActionAvailable as queryActionAvailable,
-  semanticPathToPatchPath,
-  extractDefaults
+  createIntent as createCoreIntent,
+  extractDefaults,
+  hashSchemaSync,
+  semanticPathToPatchPath
 } 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
+import {
+  compileMelDomain,
+  parse as parseMel,
+  tokenize as tokenizeMel
+} from "@manifesto-ai/compiler";
 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) {
+var BASE_LAWS = Object.freeze({ __baseLaws: true });
+function createManifesto(schemaInput, effects) {
+  if (RESERVED_EFFECT_TYPE in 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 resolved = resolveSchema(schemaInput);
+  validateReservedNamespaces(resolved.schema);
+  const manifesto = {
+    _laws: BASE_LAWS,
+    schema: resolved.schema,
+    activate() {
+      activateComposable(manifesto);
+      return createBaseRuntimeInstance(
+        createRuntimeKernel({
+          schema: resolved.schema,
+          host: createInternalHost(resolved.schema, effects),
+          MEL: buildTypedMel(resolved.schema, resolved.actionParamMetadata),
+          createIntent: buildCreateIntent()
+        })
+      );
     }
-    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;
+  };
+  return attachRuntimeKernelFactory(
+    manifesto,
+    () => createRuntimeKernel({
+      schema: resolved.schema,
+      host: createInternalHost(resolved.schema, effects),
+      MEL: buildTypedMel(resolved.schema, resolved.actionParamMetadata),
+      createIntent: buildCreateIntent()
+    })
+  );
+}
+function resolveSchema(schema) {
+  const resolved = typeof schema === "string" ? compileSchema(schema) : {
+    schema,
+    actionParamMetadata: deriveActionParamMetadata(schema)
+  };
+  return {
+    schema: withPlatformNamespaces(resolved.schema),
+    actionParamMetadata: resolved.actionParamMetadata
+  };
+}
+function compileSchema(source) {
+  const result = compileMelDomain(source, { mode: "domain" });
+  if (result.errors.length > 0) {
+    const formatted = result.errors.map((diagnostic) => {
+      const loc = diagnostic.location;
+      if (!loc || loc.start.line === 0 && loc.start.column === 0) {
+        return `[${diagnostic.code}] ${diagnostic.message}`;
       }
-    }
-    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;
+      const header = `[${diagnostic.code}] ${diagnostic.message} (${loc.start.line}:${loc.start.column})`;
+      const line = source.split("\n")[loc.start.line - 1];
+      if (!line) {
+        return header;
       }
-      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 isActionAvailable(actionName) {
-    return queryActionAvailable(schema, currentSnapshot, actionName);
-  }
-  function getAvailableActions() {
-    return queryAvailableActions(schema, currentSnapshot);
-  }
-  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);
-    }
+      const lineNum = 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, Math.max(1, line.length - loc.start.column + 1)) : 1
+      );
+      const padding = " ".repeat(lineNum.length + 3 + loc.start.column - 1);
+      return `${header}
+${lineNum} | ${line}
+${padding}${"^".repeat(underlineLen)}`;
+    }).join("\n\n");
+    throw new CompileError(result.errors, `MEL compilation failed:
+${formatted}`);
   }
-  function emitEvent(event, payload) {
-    const listeners = eventListeners.get(event);
-    if (!listeners) return;
-    for (const handler of listeners) {
-      try {
-        handler(payload);
-      } catch {
-      }
-    }
+  if (!result.schema) {
+    throw new ManifestoError("COMPILE_ERROR", "MEL compilation produced no schema");
   }
+  const schema = result.schema;
   return {
-    dispatch,
-    subscribe,
-    on,
-    isActionAvailable,
-    getAvailableActions,
-    getSnapshot,
-    dispose
+    schema,
+    actionParamMetadata: deriveActionParamMetadata(
+      schema,
+      extractActionParamOrderFromMel(source)
+    )
   };
 }
-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;
@@ -246,10 +119,7 @@ function withPlatformNamespaces(schema) {
     };
     changed = true;
   } else if (fields.$host.type !== "object") {
-    throw new ManifestoError(
-      "SCHEMA_ERROR",
-      "Reserved namespace '$host' must be an object field"
-    );
+    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;
@@ -276,10 +146,7 @@ function withPlatformNamespaces(schema) {
     };
     changed = true;
   } else if (fields.$mel.type !== "object") {
-    throw new ManifestoError(
-      "SCHEMA_ERROR",
-      "Reserved namespace '$mel' must be an object field"
-    );
+    throw new ManifestoError("SCHEMA_ERROR", "Reserved namespace '$mel' must be an object field");
   } else {
     let nextMel = fields.$mel;
     if (nextMel.default === void 0) {
@@ -309,13 +176,10 @@ function withPlatformNamespaces(schema) {
       };
       changed = true;
     } else if (guardsField.type !== "object") {
-      throw new ManifestoError(
-        "SCHEMA_ERROR",
-        "Reserved namespace '$mel.guards' must be an object field"
-      );
+      throw new ManifestoError("SCHEMA_ERROR", "Reserved namespace '$mel.guards' must be an object field");
     } else {
       let nextGuards = guardsField;
-      if (guardsField.default === void 0) {
+      if (nextGuards.default === void 0) {
         nextGuards = { ...nextGuards, default: { intent: {} } };
         changed = true;
       }
@@ -335,10 +199,7 @@ function withPlatformNamespaces(schema) {
         };
         changed = true;
       } else if (intentField.type !== "object") {
-        throw new ManifestoError(
-          "SCHEMA_ERROR",
-          "Reserved namespace '$mel.guards.intent' must be an object field"
-        );
+        throw new ManifestoError("SCHEMA_ERROR", "Reserved namespace '$mel.guards.intent' must be an object field");
       } else if (intentField.default === void 0) {
         nextGuards = {
           ...nextGuards,
@@ -361,21 +222,26 @@ function withPlatformNamespaces(schema) {
     }
     if (nextMel !== fields.$mel) {
       fields.$mel = nextMel;
-      changed = true;
     }
   }
-  if (!changed) return schema;
-  return {
+  if (!changed) {
+    return schema;
+  }
+  const nextSchema = {
     ...schema,
     state: {
       ...schema.state,
       fields
     }
   };
+  const { hash: _hash, ...schemaWithoutHash } = nextSchema;
+  return {
+    ...nextSchema,
+    hash: hashSchemaSync(schemaWithoutHash)
+  };
 }
 function validateReservedNamespaces(schema) {
-  const actions = schema.actions || {};
-  for (const actionType of Object.keys(actions)) {
+  for (const actionType of Object.keys(schema.actions ?? {})) {
     if (actionType.startsWith(RESERVED_NAMESPACE_PREFIX)) {
       throw new ManifestoError(
         "RESERVED_NAMESPACE",
@@ -384,21 +250,131 @@ function validateReservedNamespaces(schema) {
     }
   }
 }
-function createInternalHost(schema, effects, initialSnapshot) {
-  const host = createHost(schema, {
-    initialData: initialSnapshot?.data ?? extractDefaults(schema.state)
+function buildTypedMel(schema, actionParamMetadata) {
+  const actions = Object.fromEntries(
+    Object.keys(schema.actions).map((name) => {
+      const ref = {
+        __kind: "ActionRef",
+        name
+      };
+      Object.defineProperty(ref, ACTION_PARAM_NAMES, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: Object.hasOwn(actionParamMetadata, name) ? actionParamMetadata[name] : []
+      });
+      return [name, Object.freeze(ref)];
+    })
+  );
+  const state = Object.fromEntries(
+    Object.keys(schema.state.fields).filter((name) => !name.startsWith("$")).map((name) => [name, Object.freeze({
+      __kind: "FieldRef",
+      path: name
+    })])
+  );
+  const computed = Object.fromEntries(
+    Object.keys(schema.computed.fields).map((name) => [name, Object.freeze({
+      __kind: "ComputedRef",
+      path: name
+    })])
+  );
+  return Object.freeze({
+    actions: Object.freeze(actions),
+    state: Object.freeze(state),
+    computed: Object.freeze(computed)
   });
-  if (initialSnapshot) {
-    host.reset(initialSnapshot);
+}
+function buildCreateIntent() {
+  return (action, ...args) => {
+    const actionRef = action;
+    const intentId = generateUUID();
+    const input = packIntentInput(actionRef, args);
+    return createCoreIntent(
+      String(action.name),
+      input,
+      intentId
+    );
+  };
+}
+function getActionParamNames(input) {
+  if (!input || input.type !== "object" || !input.fields) {
+    return [];
+  }
+  return Object.keys(input.fields);
+}
+function deriveActionParamMetadata(schema, actionParamOrder) {
+  return Object.freeze(Object.fromEntries(
+    Object.entries(schema.actions).map(([name, action]) => {
+      const preferredOrder = actionParamOrder?.[name];
+      if (preferredOrder && preferredOrder.length > 0) {
+        return [name, Object.freeze([...preferredOrder])];
+      }
+      if (!action.input || action.input.type !== "object" || !action.input.fields) {
+        return [name, []];
+      }
+      const fieldNames = getActionParamNames(action.input);
+      return [name, fieldNames.length <= 1 ? fieldNames : null];
+    })
+  ));
+}
+function extractActionParamOrderFromMel(source) {
+  const lexed = tokenizeMel(source);
+  if (lexed.diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return void 0;
+  }
+  const parsed = parseMel(lexed.tokens);
+  if (!parsed.program) {
+    return void 0;
+  }
+  return Object.freeze(Object.fromEntries(
+    parsed.program.domain.members.filter((member) => member.kind === "action").map((action) => [action.name, Object.freeze(action.params.map((param) => param.name))])
+  ));
+}
+function packIntentInput(action, args) {
+  const paramNames = Object.hasOwn(action, ACTION_PARAM_NAMES) ? action[ACTION_PARAM_NAMES] : [];
+  if (args.length === 0) {
+    return void 0;
+  }
+  if (paramNames === null) {
+    if (args.length === 1 && isPlainObject(args[0])) {
+      return args[0];
+    }
+    throw new ManifestoError(
+      "INVALID_INTENT_ARGS",
+      `Action "${String(action.name)}" requires a single object argument because positional parameter metadata is unavailable`
+    );
+  }
+  if (paramNames.length === 0) {
+    if (args.length === 1) {
+      return args[0];
+    }
+    throw new ManifestoError(
+      "INVALID_INTENT_ARGS",
+      `Action "${String(action.name)}" does not accept multiple positional arguments`
+    );
+  }
+  if (args.length === 1 && isPlainObject(args[0]) && paramNames.length > 1) {
+    return args[0];
   }
+  return Object.fromEntries(args.map((value, index) => [
+    paramNames[index] ?? `arg${index}`,
+    value
+  ]));
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createInternalHost(schema, effects) {
+  const host = createHost(schema, {
+    initialData: extractDefaults(schema.state)
+  });
   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);
+      const patches = await appHandler(params, { snapshot: freezeSnapshot(ctx.snapshot) });
       return patches;
     };
     host.registerEffect(effectType, hostHandler);
@@ -408,6 +384,29 @@ function createInternalHost(schema, effects, initialSnapshot) {
 function isGenerateParams(params) {
   return typeof params === "object" && params !== null && "key" in params && "into" in params;
 }
+function executeSystemGet(params, snapshot) {
+  if (isGenerateParams(params)) {
+    return {
+      patches: [{
+        op: "set",
+        path: normalizeTargetPath(params.into),
+        value: generateSystemValue(params.key)
+      }]
+    };
+  }
+  const { path, target } = params;
+  const result = resolvePathValue(path, snapshot);
+  if (!target) {
+    return { patches: [] };
+  }
+  return {
+    patches: [{
+      op: "set",
+      path: normalizeTargetPath(target),
+      value: result.value
+    }]
+  };
+}
 function generateSystemValue(key) {
   switch (key) {
     case "uuid":
@@ -421,37 +420,10 @@ function generateSystemValue(key) {
       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 normalizeTargetPath(path) {
+  const normalized = normalizePath(path);
+  const withoutDataRoot = normalized.startsWith("data.") ? normalized.slice("data.".length) : normalized;
+  return semanticPathToPatchPath(withoutDataRoot);
 }
 function normalizePath(path) {
   if (path.startsWith("/")) {
@@ -459,19 +431,13 @@ function normalizePath(path) {
   }
   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);
+  const [root, ...rest] = parts;
   let current;
   switch (root) {
     case "data":
@@ -489,116 +455,39 @@ function resolvePathValue(path, snapshot) {
     default:
       current = snapshot.data;
       rest.unshift(root);
+      break;
   }
   for (const part of rest) {
-    if (current === null || current === void 0) {
-      return { value: void 0, found: false };
-    }
-    if (typeof current !== "object") {
+    if (current === null || current === void 0 || typeof current !== "object") {
       return { value: void 0, found: false };
     }
     current = current[part];
   }
   return { value: current, found: current !== void 0 };
 }
-function generateIntentId() {
-  return generateUUID();
+function freezeSnapshot(snapshot) {
+  return Object.freeze(structuredClone(snapshot));
 }
-
-// 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) {
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     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);
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const random = Math.random() * 16 | 0;
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.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 { createWorld } from "@manifesto-ai/world";
+import { createSnapshot } from "@manifesto-ai/core";
 export {
+  AlreadyActivatedError,
   CompileError,
-  DispatchRejectedError,
   DisposedError,
   ManifestoError,
   ReservedEffectError,
-  createCore,
-  createIntent,
   createManifesto,
-  createSnapshot,
-  createWorld,
-  defineOps,
-  dispatchAsync
+  createSnapshot
 };
 //# sourceMappingURL=index.js.map