@manifesto-ai/sdk 3.4.0 → 3.5.0

package/dist/chunk-2YBJP5JT.js

@@ -1,747 +0,0 @@
-// 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 use a disposed Manifesto runtime");
-    this.name = "DisposedError";
-  }
-};
-var AlreadyActivatedError = class extends ManifestoError {
-  constructor() {
-    super("ALREADY_ACTIVATED", "ComposableManifesto.activate() may only be called once");
-    this.name = "AlreadyActivatedError";
-  }
-};
-
-// src/internal.ts
-import {
-  getAvailableActions as queryAvailableActions,
-  isActionAvailable as queryActionAvailable
-} from "@manifesto-ai/core";
-
-// src/snapshot-projection.ts
-var COLLECTION_CONTEXT_ROOTS = /* @__PURE__ */ new Set(["$item", "$index", "$array"]);
-function buildSnapshotProjectionPlan(schema) {
-  const computedFields = schema.computed.fields;
-  const memo = /* @__PURE__ */ new Map();
-  function isVisibleComputed(name, visiting) {
-    const cached = memo.get(name);
-    if (cached !== void 0) {
-      return cached;
-    }
-    if (visiting.has(name)) {
-      return false;
-    }
-    visiting.add(name);
-    const field = computedFields[name];
-    if (!field) {
-      visiting.delete(name);
-      memo.set(name, true);
-      return true;
-    }
-    for (const path of collectExprGetPaths(field.expr)) {
-      if (isPlatformDependency(path)) {
-        visiting.delete(name);
-        memo.set(name, false);
-        return false;
-      }
-      const computedDependency = resolveComputedDependency(path, computedFields);
-      if (computedDependency !== null && !isVisibleComputed(computedDependency, visiting)) {
-        visiting.delete(name);
-        memo.set(name, false);
-        return false;
-      }
-    }
-    visiting.delete(name);
-    memo.set(name, true);
-    return true;
-  }
-  const visibleComputedKeys = Object.keys(computedFields).filter((name) => isVisibleComputed(name, /* @__PURE__ */ new Set()));
-  return {
-    visibleComputedKeys
-  };
-}
-function projectCanonicalSnapshot(snapshot, plan) {
-  return {
-    data: projectData(snapshot.data),
-    computed: projectComputed(snapshot.computed, plan),
-    system: {
-      status: snapshot.system.status,
-      lastError: snapshot.system.lastError
-    },
-    meta: {
-      schemaHash: snapshot.meta.schemaHash
-    }
-  };
-}
-function projectEffectContextSnapshot(snapshot, plan) {
-  return projectCanonicalSnapshot(snapshot, plan);
-}
-function cloneAndDeepFreeze(value) {
-  return deepFreeze(structuredClone(value));
-}
-function projectedSnapshotsEqual(left, right) {
-  return cycleSafeEqual(left, right);
-}
-function projectData(data) {
-  if (data === null || data === void 0) {
-    return data;
-  }
-  if (Array.isArray(data) || typeof data !== "object") {
-    return structuredClone(data);
-  }
-  const projected = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (!key.startsWith("$")) {
-      projected[key] = value;
-    }
-  }
-  return structuredClone(projected);
-}
-function projectComputed(computed, plan) {
-  const projected = {};
-  for (const key of plan.visibleComputedKeys) {
-    if (Object.prototype.hasOwnProperty.call(computed, key)) {
-      projected[key] = computed[key];
-    }
-  }
-  return structuredClone(projected);
-}
-function resolveComputedDependency(dep, computedFields) {
-  if (Object.prototype.hasOwnProperty.call(computedFields, dep)) {
-    return dep;
-  }
-  if (!dep.startsWith("computed.")) {
-    return null;
-  }
-  const candidate = dep.slice("computed.".length);
-  return Object.prototype.hasOwnProperty.call(computedFields, candidate) ? candidate : null;
-}
-function isPlatformDependency(dep) {
-  const normalized = dep.startsWith("data.") ? dep.slice("data.".length) : dep;
-  const root = normalized.split(".")[0] ?? "";
-  if (!root.startsWith("$")) {
-    return false;
-  }
-  return !COLLECTION_CONTEXT_ROOTS.has(root);
-}
-function collectExprGetPaths(expr) {
-  const paths = [];
-  const seen = /* @__PURE__ */ new WeakSet();
-  const visit = (node) => {
-    if (node === null || node === void 0) {
-      return;
-    }
-    if (Array.isArray(node)) {
-      node.forEach(visit);
-      return;
-    }
-    if (typeof node !== "object") {
-      return;
-    }
-    const objectNode = node;
-    if (seen.has(objectNode)) {
-      return;
-    }
-    seen.add(objectNode);
-    if (objectNode.kind === "lit") {
-      return;
-    }
-    if (objectNode.kind === "get" && typeof objectNode.path === "string") {
-      paths.push(objectNode.path);
-      return;
-    }
-    for (const value of Object.values(objectNode)) {
-      visit(value);
-    }
-  };
-  visit(expr);
-  return paths;
-}
-function cycleSafeEqual(left, right) {
-  return cycleSafeEqualInternal(left, right, /* @__PURE__ */ new WeakMap());
-}
-function cycleSafeEqualInternal(left, right, seen) {
-  if (Object.is(left, right)) {
-    return true;
-  }
-  if (typeof left !== typeof right) {
-    return false;
-  }
-  if (left === null || right === null) {
-    return left === right;
-  }
-  if (typeof left !== "object" || typeof right !== "object") {
-    return false;
-  }
-  const leftObject = left;
-  const rightObject = right;
-  const leftTag = Object.prototype.toString.call(leftObject);
-  const rightTag = Object.prototype.toString.call(rightObject);
-  if (leftTag !== rightTag) {
-    return false;
-  }
-  let seenRight = seen.get(leftObject);
-  if (seenRight?.has(rightObject)) {
-    return true;
-  }
-  if (!seenRight) {
-    seenRight = /* @__PURE__ */ new WeakSet();
-    seen.set(leftObject, seenRight);
-  }
-  seenRight.add(rightObject);
-  if (Array.isArray(leftObject) && Array.isArray(rightObject)) {
-    if (leftObject.length !== rightObject.length) {
-      return false;
-    }
-    for (let index = 0; index < leftObject.length; index += 1) {
-      const leftHasValue = Object.prototype.hasOwnProperty.call(leftObject, index);
-      const rightHasValue = Object.prototype.hasOwnProperty.call(rightObject, index);
-      if (leftHasValue !== rightHasValue) {
-        return false;
-      }
-      if (leftHasValue && !cycleSafeEqualInternal(leftObject[index], rightObject[index], seen)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (leftObject instanceof Date && rightObject instanceof Date) {
-    return leftObject.getTime() === rightObject.getTime();
-  }
-  if (leftObject instanceof RegExp && rightObject instanceof RegExp) {
-    return leftObject.source === rightObject.source && leftObject.flags === rightObject.flags;
-  }
-  if (ArrayBuffer.isView(leftObject) && ArrayBuffer.isView(rightObject)) {
-    if (leftObject.constructor !== rightObject.constructor) {
-      return false;
-    }
-    if (leftObject.byteLength !== rightObject.byteLength) {
-      return false;
-    }
-    const leftBytes = new Uint8Array(
-      leftObject.buffer,
-      leftObject.byteOffset,
-      leftObject.byteLength
-    );
-    const rightBytes = new Uint8Array(
-      rightObject.buffer,
-      rightObject.byteOffset,
-      rightObject.byteLength
-    );
-    return leftBytes.every((value, index) => value === rightBytes[index]);
-  }
-  if (leftObject instanceof ArrayBuffer && rightObject instanceof ArrayBuffer) {
-    if (leftObject.byteLength !== rightObject.byteLength) {
-      return false;
-    }
-    const leftBytes = new Uint8Array(leftObject);
-    const rightBytes = new Uint8Array(rightObject);
-    return leftBytes.every((value, index) => value === rightBytes[index]);
-  }
-  if (leftObject instanceof Map && rightObject instanceof Map) {
-    if (leftObject.size !== rightObject.size) {
-      return false;
-    }
-    const leftEntries = Array.from(leftObject.entries());
-    const rightEntries = Array.from(rightObject.entries());
-    return leftEntries.every(([leftKey, leftValue], index) => {
-      const rightEntry = rightEntries[index];
-      if (!rightEntry) {
-        return false;
-      }
-      const [rightKey, rightValue] = rightEntry;
-      return cycleSafeEqualInternal(leftKey, rightKey, seen) && cycleSafeEqualInternal(leftValue, rightValue, seen);
-    });
-  }
-  if (leftObject instanceof Set && rightObject instanceof Set) {
-    if (leftObject.size !== rightObject.size) {
-      return false;
-    }
-    const leftValues = Array.from(leftObject.values());
-    const rightValues = Array.from(rightObject.values());
-    return leftValues.every((value, index) => cycleSafeEqualInternal(value, rightValues[index], seen));
-  }
-  const leftKeys = getComparableObjectKeys(leftObject);
-  const rightKeys = getComparableObjectKeys(rightObject);
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (let index = 0; index < leftKeys.length; index += 1) {
-    const leftKey = leftKeys[index];
-    const rightKey = rightKeys[index];
-    if (leftKey !== rightKey) {
-      return false;
-    }
-    const leftValue = leftObject[leftKey];
-    const rightValue = rightObject[rightKey];
-    if (!cycleSafeEqualInternal(leftValue, rightValue, seen)) {
-      return false;
-    }
-  }
-  return true;
-}
-function getComparableObjectKeys(value) {
-  return Object.keys(value).filter((key) => value[key] !== void 0).sort();
-}
-function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null || value === void 0 || typeof value !== "object") {
-    return value;
-  }
-  if (isBinaryValue(value)) {
-    return cloneBinaryValue(value);
-  }
-  const objectValue = value;
-  if (seen.has(objectValue)) {
-    return value;
-  }
-  if (Object.isFrozen(value)) {
-    return value;
-  }
-  seen.add(objectValue);
-  for (const key of Reflect.ownKeys(objectValue)) {
-    const child = objectValue[key];
-    if (isBinaryValue(child)) {
-      defineReadOnlyBinaryProperty(objectValue, key, child);
-      continue;
-    }
-    deepFreeze(child, seen);
-  }
-  return Object.freeze(value);
-}
-function isBinaryValue(value) {
-  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-}
-function cloneBinaryValue(value) {
-  return structuredClone(value);
-}
-function defineReadOnlyBinaryProperty(target, key, value) {
-  const descriptor = Object.getOwnPropertyDescriptor(target, key);
-  if (!descriptor || !("value" in descriptor)) {
-    return;
-  }
-  Object.defineProperty(target, key, {
-    enumerable: descriptor.enumerable ?? true,
-    configurable: false,
-    get() {
-      return cloneBinaryValue(value);
-    }
-  });
-}
-
-// src/internal.ts
-var ACTION_PARAM_NAMES = /* @__PURE__ */ Symbol("manifesto-sdk.action-param-names");
-var RUNTIME_KERNEL_FACTORY = /* @__PURE__ */ Symbol("manifesto-sdk.runtime-kernel-factory");
-var ACTIVATION_STATE = /* @__PURE__ */ Symbol("manifesto-sdk.activation-state");
-function attachRuntimeKernelFactory(manifesto, factory, activationState) {
-  Object.defineProperty(manifesto, RUNTIME_KERNEL_FACTORY, {
-    enumerable: false,
-    configurable: false,
-    writable: false,
-    value: factory
-  });
-  const state = activationState ?? getExistingActivationState(manifesto) ?? {
-    activated: false
-  };
-  if (!getExistingActivationState(manifesto)) {
-    Object.defineProperty(manifesto, ACTIVATION_STATE, {
-      enumerable: false,
-      configurable: false,
-      writable: false,
-      value: state
-    });
-  }
-  return manifesto;
-}
-function getRuntimeKernelFactory(manifesto) {
-  const internal = manifesto;
-  const factory = internal[RUNTIME_KERNEL_FACTORY];
-  if (typeof factory !== "function") {
-    throw new ManifestoError(
-      "SCHEMA_ERROR",
-      "ComposableManifesto is missing its runtime kernel factory"
-    );
-  }
-  return factory;
-}
-function getActivationState(manifesto) {
-  const internal = manifesto;
-  const state = internal[ACTIVATION_STATE];
-  if (!state) {
-    throw new ManifestoError(
-      "SCHEMA_ERROR",
-      "ComposableManifesto is missing its activation state"
-    );
-  }
-  return state;
-}
-function assertComposableNotActivated(manifesto) {
-  if (getActivationState(manifesto).activated) {
-    throw new AlreadyActivatedError();
-  }
-}
-function activateComposable(manifesto) {
-  const state = getActivationState(manifesto);
-  if (state.activated) {
-    throw new AlreadyActivatedError();
-  }
-  state.activated = true;
-}
-function getExistingActivationState(manifesto) {
-  const internal = manifesto;
-  return internal[ACTIVATION_STATE] ?? null;
-}
-function getActionInputFieldNames(input) {
-  if (!input || input.type !== "object" || !input.fields) {
-    return [];
-  }
-  return Object.keys(input.fields);
-}
-function createRuntimeKernel({
-  schema,
-  projectionPlan,
-  host,
-  MEL,
-  createIntent
-}) {
-  const initialCanonicalSnapshot = host.getSnapshot();
-  if (!initialCanonicalSnapshot) {
-    throw new ManifestoError("SCHEMA_ERROR", "Host failed to initialize its genesis snapshot");
-  }
-  let visibleCanonicalSnapshot = structuredClone(initialCanonicalSnapshot);
-  let visibleProjectedSnapshot = cloneAndDeepFreeze(
-    projectCanonicalSnapshot(
-      visibleCanonicalSnapshot,
-      projectionPlan
-    )
-  );
-  let visibleCanonicalReadSnapshot = cloneAndDeepFreeze(
-    visibleCanonicalSnapshot
-  );
-  let dispatchQueue = Promise.resolve();
-  let disposed = false;
-  const actionNames = Object.keys(schema.actions);
-  const actionMetadataByName = Object.freeze(
-    Object.fromEntries(
-      actionNames.map((name) => {
-        const action = schema.actions[name];
-        const actionRef = MEL.actions[name];
-        const rawParams = actionRef?.[ACTION_PARAM_NAMES];
-        const params = Object.freeze(
-          Array.isArray(rawParams) ? [...rawParams] : getActionInputFieldNames(action.input)
-        );
-        return [name, Object.freeze({
-          name,
-          params,
-          input: action.input,
-          description: action.description
-        })];
-      })
-    )
-  );
-  const actionMetadata = Object.freeze(
-    actionNames.map((name) => actionMetadataByName[name])
-  );
-  const subscribers = /* @__PURE__ */ new Set();
-  const eventListeners = /* @__PURE__ */ new Map();
-  function subscribe(selector, listener) {
-    if (disposed) {
-      return () => {
-      };
-    }
-    let lastValue;
-    let initialized = false;
-    try {
-      lastValue = selector(visibleProjectedSnapshot);
-      initialized = true;
-    } catch {
-      lastValue = void 0;
-      initialized = false;
-    }
-    const subscriber = {
-      selector,
-      listener,
-      lastValue,
-      initialized
-    };
-    subscribers.add(subscriber);
-    return () => {
-      subscribers.delete(subscriber);
-    };
-  }
-  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 visibleProjectedSnapshot;
-  }
-  function getCanonicalSnapshot() {
-    return visibleCanonicalReadSnapshot;
-  }
-  function getAvailableActions() {
-    return queryAvailableActions(
-      schema,
-      visibleCanonicalSnapshot
-    );
-  }
-  const getActionMetadata = ((name) => {
-    if (name !== void 0) {
-      return actionMetadataByName[String(name)];
-    }
-    return actionMetadata;
-  });
-  function isActionAvailable(name) {
-    return queryActionAvailable(schema, visibleCanonicalSnapshot, String(name));
-  }
-  function dispose() {
-    if (disposed) {
-      return;
-    }
-    disposed = true;
-    subscribers.clear();
-    eventListeners.clear();
-  }
-  function setVisibleSnapshot(snapshot, options) {
-    visibleCanonicalSnapshot = structuredClone(snapshot);
-    host.reset(structuredClone(visibleCanonicalSnapshot));
-    visibleCanonicalReadSnapshot = cloneAndDeepFreeze(
-      visibleCanonicalSnapshot
-    );
-    const nextProjectedSnapshot = projectCanonicalSnapshot(
-      visibleCanonicalSnapshot,
-      projectionPlan
-    );
-    const projectedChanged = !projectedSnapshotsEqual(
-      nextProjectedSnapshot,
-      visibleProjectedSnapshot
-    );
-    if (projectedChanged) {
-      visibleProjectedSnapshot = cloneAndDeepFreeze(nextProjectedSnapshot);
-    }
-    if (options?.notify !== false && projectedChanged) {
-      notifySubscribers(visibleProjectedSnapshot);
-    }
-    return visibleProjectedSnapshot;
-  }
-  function restoreVisibleSnapshot() {
-    host.reset(structuredClone(visibleCanonicalSnapshot));
-  }
-  function emitEvent(event, payload) {
-    const listeners = eventListeners.get(event);
-    if (!listeners) {
-      return;
-    }
-    for (const handler of listeners) {
-      try {
-        handler(payload);
-      } catch {
-      }
-    }
-  }
-  function enqueue(task) {
-    const result = dispatchQueue.catch(() => {
-    }).then(task);
-    dispatchQueue = result.then(() => void 0, () => void 0);
-    return result;
-  }
-  function ensureIntentId(intent) {
-    if (intent.intentId && intent.intentId.length > 0) {
-      return intent;
-    }
-    return {
-      ...intent,
-      intentId: generateUUID()
-    };
-  }
-  async function executeHost(intent, options) {
-    return host.dispatch(intent, options);
-  }
-  function rejectUnavailable(intent) {
-    const error = new ManifestoError(
-      "ACTION_UNAVAILABLE",
-      `Action "${intent.type}" is unavailable against the current visible snapshot`
-    );
-    emitEvent("dispatch:rejected", {
-      intentId: intent.intentId ?? "",
-      intent,
-      reason: error.message
-    });
-    throw error;
-  }
-  function notifySubscribers(snapshot) {
-    for (const subscriber of subscribers) {
-      let selected;
-      try {
-        selected = subscriber.selector(snapshot);
-      } catch {
-        continue;
-      }
-      if (subscriber.initialized && Object.is(subscriber.lastValue, selected)) {
-        continue;
-      }
-      subscriber.lastValue = selected;
-      subscriber.initialized = true;
-      try {
-        subscriber.listener(selected);
-      } catch {
-      }
-    }
-  }
-  return {
-    schema,
-    MEL,
-    createIntent,
-    subscribe,
-    on,
-    getSnapshot,
-    getAvailableActions,
-    getActionMetadata,
-    isActionAvailable,
-    dispose,
-    isDisposed: () => disposed,
-    getCanonicalSnapshot,
-    getVisibleCoreSnapshot: () => structuredClone(visibleCanonicalSnapshot),
-    setVisibleSnapshot,
-    restoreVisibleSnapshot,
-    emitEvent,
-    enqueue,
-    ensureIntentId,
-    executeHost,
-    rejectUnavailable
-  };
-}
-function createBaseRuntimeInstance(kernel) {
-  async function processIntent(intent) {
-    if (kernel.isDisposed()) {
-      throw new DisposedError();
-    }
-    if (!kernel.isActionAvailable(intent.type)) {
-      return kernel.rejectUnavailable(intent);
-    }
-    let result;
-    try {
-      result = await kernel.executeHost(intent);
-    } catch (error) {
-      const failure = toError(error);
-      kernel.emitEvent("dispatch:failed", {
-        intentId: intent.intentId ?? "",
-        intent,
-        error: failure
-      });
-      throw failure;
-    }
-    if (result.status === "error") {
-      const publishedSnapshot2 = kernel.setVisibleSnapshot(result.snapshot);
-      const failure = result.error ?? new ManifestoError("HOST_ERROR", "Host dispatch failed");
-      kernel.emitEvent("dispatch:failed", {
-        intentId: intent.intentId ?? "",
-        intent,
-        error: failure,
-        snapshot: publishedSnapshot2
-      });
-      throw failure;
-    }
-    const publishedSnapshot = kernel.setVisibleSnapshot(result.snapshot);
-    kernel.emitEvent("dispatch:completed", {
-      intentId: intent.intentId ?? "",
-      intent,
-      snapshot: publishedSnapshot
-    });
-    return publishedSnapshot;
-  }
-  function dispatchAsync(intent) {
-    if (kernel.isDisposed()) {
-      return Promise.reject(new DisposedError());
-    }
-    const enrichedIntent = kernel.ensureIntentId(intent);
-    return kernel.enqueue(() => processIntent(enrichedIntent));
-  }
-  return {
-    createIntent: kernel.createIntent,
-    dispatchAsync,
-    subscribe: kernel.subscribe,
-    on: kernel.on,
-    getSnapshot: kernel.getSnapshot,
-    getCanonicalSnapshot: kernel.getCanonicalSnapshot,
-    getAvailableActions: kernel.getAvailableActions,
-    getActionMetadata: kernel.getActionMetadata,
-    isActionAvailable: kernel.isActionAvailable,
-    MEL: kernel.MEL,
-    schema: kernel.schema,
-    dispose: kernel.dispose
-  };
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function generateUUID() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  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);
-  });
-}
-
-export {
-  ManifestoError,
-  ReservedEffectError,
-  CompileError,
-  DisposedError,
-  AlreadyActivatedError,
-  buildSnapshotProjectionPlan,
-  projectEffectContextSnapshot,
-  cloneAndDeepFreeze,
-  ACTION_PARAM_NAMES,
-  attachRuntimeKernelFactory,
-  getRuntimeKernelFactory,
-  getActivationState,
-  assertComposableNotActivated,
-  activateComposable,
-  createRuntimeKernel,
-  createBaseRuntimeInstance
-};
-//# sourceMappingURL=chunk-2YBJP5JT.js.map