@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/chunk-6SXYJQST.js

@@ -0,0 +1,253 @@
+import {
+  StorybookError
+} from "./chunk-V5M7Q4HT.js";
+import {
+  require_picocolors_browser
+} from "./chunk-SC67XZST.js";
+import {
+  __toESM
+} from "./chunk-IMSF75WX.js";
+
+// src/server-errors.ts
+var import_picocolors = __toESM(require_picocolors_browser(), 1);
+import { dedent } from "ts-dedent";
+
+// src/shared/open-service/errors.ts
+function formatIssuePath(path) {
+  return path?.length ? path.map((segment) => {
+    let key = typeof segment == "object" && segment !== null && "key" in segment ? segment.key : segment;
+    return typeof key == "number" ? `[${key}]` : `.${String(key)}`;
+  }).join("").replace(/^\./, "") : "";
+}
+function formatIssues(issues) {
+  return issues.map((issue) => {
+    let path = formatIssuePath(issue.path);
+    return path === "" ? issue.message : `${path}: ${issue.message}`;
+  }).join(`
+`);
+}
+
+// src/server-errors.ts
+var OpenServiceValidationError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceValidationError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 5,
+      message: `Invalid ${data.phase} for ${data.kind} "${data.serviceId}.${data.name}":
+${formatIssues(
+        data.issues
+      )}`
+    });
+    this.data = data;
+  }
+};
+var OpenServiceMissingServiceError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceMissingServiceError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 7,
+      message: `No registered service with id "${data.serviceId}" exists in this environment.`
+    });
+    this.data = data;
+  }
+}, OpenServiceInternalServiceError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceInternalServiceError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 19,
+      message: `Service "${data.serviceId}" is internal. Pass { internal: true } to getService() only if you intentionally depend on an unstable OSA surface. Internal services may change without notice.`
+    });
+    this.data = data;
+  }
+}, OpenServiceUnimplementedOperationError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceUnimplementedOperationError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 8,
+      message: `${data.kind[0].toUpperCase()}${data.kind.slice(1)} "${data.serviceId}.${data.name}" is not implemented for this environment.`
+    });
+    this.data = data;
+  }
+}, OpenServiceInvalidStaticPathError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceInvalidStaticPathError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 10,
+      message: `Invalid static path "${data.path}" for query "${data.serviceId}.${data.name}": use a relative path with forward slashes and no ".." segments.`
+    });
+    this.data = data;
+  }
+}, OpenServiceAsyncSchemaError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceAsyncSchemaError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 9,
+      message: `Async schema for ${data.kind} "${data.serviceId}.${data.name}" (${data.phase}): query input and output schemas must validate synchronously.`
+    });
+    this.data = data;
+  }
+}, OpenServiceLoadedDrainExceededError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceLoadedDrainExceededError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 11,
+      message: `Query "${data.serviceId}.${data.name}".loaded(...) did not settle after ${data.iterations} drain iterations. Check for handlers that keep discovering new dependencies after every state change.`
+    });
+    this.data = data;
+  }
+};
+var OpenServiceMissingChannelError = class extends StorybookError {
+  constructor(data = {}) {
+    super({
+      name: "OpenServiceMissingChannelError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 13,
+      message: data.serviceId ? `Cannot register service "${data.serviceId}": the Forkbook addons channel is not installed in this runtime.` : "The Forkbook addons channel is not installed in this runtime."
+    });
+    this.data = data;
+  }
+}, OpenServiceRemoteCommandDisconnectedError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceRemoteCommandDisconnectedError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 14,
+      message: `Service "${data.serviceId}" was unregistered before a remote command resolved.`
+    });
+    this.data = data;
+  }
+}, OpenServiceRemoteCommandUnhandledError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceRemoteCommandUnhandledError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 15,
+      message: data.delegated ? `The Forkbook this runtime is attached to did not acknowledge remote command "${data.serviceId}.${data.commandName}" in time \u2014 it may be busy or unreachable. Retry; note the command may still have executed on that instance.` : `No runtime acknowledged remote command "${data.serviceId}.${data.commandName}"; its handler is not implemented in any connected runtime.`
+    });
+    this.data = data;
+  }
+}, OpenServiceRemoteCommandConfigDriftError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceRemoteCommandConfigDriftError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 30,
+      message: `The Forkbook this runtime is attached to reported it has no handler for remote command "${data.serviceId}.${data.commandName}". The two processes are running different configurations (for example a feature flag enabled in one but not the other). Restart the attached Forkbook with a configuration matching this process.`
+    });
+    this.data = data;
+  }
+}, OpenServiceAsyncRecipeError = class extends StorybookError {
+  constructor() {
+    super({
+      name: "OpenServiceAsyncRecipeError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 31,
+      message: "setState recipes must be synchronous. A write after an await would change state without authoring a sync entry. Split the command into one setState per synchronous step."
+    });
+  }
+}, OpenServiceCyclicStateError = class extends StorybookError {
+  constructor() {
+    super({
+      name: "OpenServiceCyclicStateError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 32,
+      message: "Service state must be JSON-serializable, but the value is cyclic or nested more than 256 levels deep. Store an id and look the value up in a query instead of a reference."
+    });
+  }
+}, OpenServiceOperationNameCollisionError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceOperationNameCollisionError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 16,
+      message: `Service "${data.serviceId}" cannot register "${data.operationName}" as both a query and a command.`
+    });
+    this.data = data;
+  }
+};
+var OpenServiceMissingToolsetError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceMissingToolsetError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 23,
+      message: `No registered toolset with id "${data.toolsetId}" exists in this environment.`
+    });
+    this.data = data;
+  }
+}, OpenServiceDuplicateToolsetError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceDuplicateToolsetError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 24,
+      message: `A toolset with id "${data.toolsetId}" is already registered. Each public toolset must be registered exactly once.`
+    });
+    this.data = data;
+  }
+};
+var OpenServiceInvalidToolsetMethodIdError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceInvalidToolsetMethodIdError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 28,
+      message: `Invalid toolset method id "${data.methodId}". Expected exactly one separator: toolsetId.methodName.`
+    });
+    this.data = data;
+  }
+}, OpenServiceDuplicateToolNameError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "OpenServiceDuplicateToolNameError",
+      category: "CORE-COMMON" /* CORE_COMMON */,
+      code: 29,
+      message: data.transport === "mcp" ? `Derived MCP tool name "${data.derivedName}" collides between "${data.first}" and "${data.second}". Rename one toolset id or method key.` : `Derived CLI method name "${data.derivedName}" collides between "${data.first}" and "${data.second}" in the same toolset. Rename one method key.`
+    });
+    this.data = data;
+  }
+};
+var StatusTypeIdMismatchError = class extends StorybookError {
+  constructor(data) {
+    super({
+      name: "StatusTypeIdMismatchError",
+      category: "CORE-SERVER" /* CORE_SERVER */,
+      code: 16,
+      message: `Status has typeId "${data.status.typeId}" but was added to store with typeId "${data.typeId}". Full status: ${JSON.stringify(
+        data.status,
+        null,
+        2
+      )}`
+    });
+    this.data = data;
+  }
+};
+
+export {
+  OpenServiceValidationError,
+  OpenServiceMissingServiceError,
+  OpenServiceInternalServiceError,
+  OpenServiceUnimplementedOperationError,
+  OpenServiceInvalidStaticPathError,
+  OpenServiceAsyncSchemaError,
+  OpenServiceLoadedDrainExceededError,
+  OpenServiceMissingChannelError,
+  OpenServiceRemoteCommandDisconnectedError,
+  OpenServiceRemoteCommandUnhandledError,
+  OpenServiceRemoteCommandConfigDriftError,
+  OpenServiceAsyncRecipeError,
+  OpenServiceCyclicStateError,
+  OpenServiceOperationNameCollisionError,
+  OpenServiceMissingToolsetError,
+  OpenServiceDuplicateToolsetError,
+  OpenServiceInvalidToolsetMethodIdError,
+  OpenServiceDuplicateToolNameError,
+  StatusTypeIdMismatchError
+};

package/dist/_browser-chunks/chunk-AYRF6EJB.js

@@ -0,0 +1,36 @@
+import {
+  toCliMethodName
+} from "./chunk-LEVSOOLQ.js";
+
+// src/shared/open-service/toolset-definition.ts
+function defineToolset(definition) {
+  for (let [methodName, method] of Object.entries(definition.methods)) {
+    let input = method.input;
+    if (input["~standard"].vendor === "valibot" && input.type !== "strict_object")
+      throw new Error(
+        `Toolset method "${definition.id}.${methodName}" must declare its input with v.strictObject, got a valibot "${String(input.type)}" schema. Undeclared arguments would otherwise be silently dropped or passed through instead of rejected.`
+      );
+  }
+  return definition;
+}
+function resolveToolsetDescription(description, context) {
+  return typeof description == "function" ? description(context) : description;
+}
+async function invokeToolsetMethod(toolset, methodName, input, context) {
+  let { telemetry, ...outcome } = await toolset.methods[methodName].handler(input, context);
+  return telemetry ? {
+    ...outcome,
+    telemetry: {
+      ...telemetry,
+      toolset: toolset.id,
+      tool: toCliMethodName(methodName),
+      event: `tool:${toolset.id}_${methodName}`
+    }
+  } : outcome;
+}
+
+export {
+  defineToolset,
+  resolveToolsetDescription,
+  invokeToolsetMethod
+};

package/dist/_browser-chunks/chunk-B4AUNNU4.js

@@ -0,0 +1,156 @@
+import {
+  noop
+} from "./chunk-NZMVUW5T.js";
+import {
+  arrayBufferTag,
+  arrayTag,
+  bigInt64ArrayTag,
+  bigUint64ArrayTag,
+  booleanTag,
+  dataViewTag,
+  dateTag,
+  errorTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  functionTag,
+  getSymbols,
+  getTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  int8ArrayTag,
+  isBuffer,
+  isPlainObject,
+  mapTag,
+  numberTag,
+  objectTag,
+  regexpTag,
+  setTag,
+  stringTag,
+  symbolTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag
+} from "./chunk-JWSKPMPC.js";
+
+// ../../node_modules/es-toolkit/dist/predicate/isFunction.mjs
+function isFunction(value) {
+  return typeof value == "function";
+}
+
+// ../../node_modules/es-toolkit/dist/compat/util/eq.mjs
+function eq(value, other) {
+  return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+function isEqualWith(a, b, areValuesEqual) {
+  return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+  let result = areValuesEqual(a, b, property, aParent, bParent, stack);
+  if (result !== void 0) return result;
+  if (typeof a == typeof b) switch (typeof a) {
+    case "bigint":
+    case "string":
+    case "boolean":
+    case "symbol":
+    case "undefined":
+      return a === b;
+    case "number":
+      return a === b || Object.is(a, b);
+    case "function":
+      return a === b;
+    case "object":
+      return areObjectsEqual(a, b, stack, areValuesEqual);
+  }
+  return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+  if (Object.is(a, b)) return !0;
+  let aTag = getTag(a), bTag = getTag(b);
+  if (aTag === "[object Arguments]" && (aTag = objectTag), bTag === "[object Arguments]" && (bTag = objectTag), aTag !== bTag) return !1;
+  switch (aTag) {
+    case stringTag:
+      return a.toString() === b.toString();
+    case numberTag:
+      return eq(a.valueOf(), b.valueOf());
+    case booleanTag:
+    case dateTag:
+    case symbolTag:
+      return Object.is(a.valueOf(), b.valueOf());
+    case regexpTag:
+      return a.source === b.source && a.flags === b.flags;
+    case functionTag:
+      return a === b;
+  }
+  stack = stack ?? /* @__PURE__ */ new Map();
+  let aStack = stack.get(a), bStack = stack.get(b);
+  if (aStack != null && bStack != null) return aStack === b;
+  stack.set(a, b), stack.set(b, a);
+  try {
+    switch (aTag) {
+      case mapTag:
+        if (a.size !== b.size) return !1;
+        for (let [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return !1;
+        return !0;
+      case setTag: {
+        if (a.size !== b.size) return !1;
+        let aValues = Array.from(a.values()), bValues = Array.from(b.values());
+        for (let i = 0; i < aValues.length; i++) {
+          let aValue = aValues[i], index = bValues.findIndex((bValue) => isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual));
+          if (index === -1) return !1;
+          bValues.splice(index, 1);
+        }
+        return !0;
+      }
+      case arrayTag:
+      case uint8ArrayTag:
+      case uint8ClampedArrayTag:
+      case uint16ArrayTag:
+      case uint32ArrayTag:
+      case bigUint64ArrayTag:
+      case int8ArrayTag:
+      case int16ArrayTag:
+      case int32ArrayTag:
+      case bigInt64ArrayTag:
+      case float32ArrayTag:
+      case float64ArrayTag:
+        if (isBuffer(a) !== isBuffer(b) || a.length !== b.length) return !1;
+        for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return !1;
+        return !0;
+      case arrayBufferTag:
+        return a.byteLength !== b.byteLength ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case dataViewTag:
+        return a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case errorTag:
+        return a.name === b.name && a.message === b.message;
+      case objectTag: {
+        if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return !1;
+        let aKeys = [...Object.keys(a), ...getSymbols(a)], bKeys = [...Object.keys(b), ...getSymbols(b)];
+        if (aKeys.length !== bKeys.length) return !1;
+        for (let i = 0; i < aKeys.length; i++) {
+          let propKey = aKeys[i], aProp = a[propKey];
+          if (!Object.hasOwn(b, propKey)) return !1;
+          let bProp = b[propKey];
+          if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return !1;
+        }
+        return !0;
+      }
+      default:
+        return !1;
+    }
+  } finally {
+    stack.delete(a), stack.delete(b);
+  }
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function isEqual(a, b) {
+  return isEqualWith(a, b, noop);
+}
+
+export {
+  isEqual,
+  isFunction
+};