@outfitter/contracts 0.4.1 → 0.4.2

package/dist/shared/@outfitter/contracts-d0tq2adf.js

@@ -1,60 +0,0 @@
-// @bun
-// packages/contracts/src/capabilities.ts
-var CAPABILITY_SURFACES = ["cli", "mcp", "api", "server"];
-var DEFAULT_ACTION_SURFACES = ["cli", "mcp"];
-function capability(surfaces = DEFAULT_ACTION_SURFACES, notes) {
-  return notes ? { surfaces, notes } : { surfaces };
-}
-function capabilityAll(notes) {
-  return capability(CAPABILITY_SURFACES, notes);
-}
-var ACTION_CAPABILITIES = {
-  navigate: capability(),
-  back: capability(),
-  forward: capability(),
-  reload: capability(),
-  tab: capability(),
-  tabs: capability(),
-  newTab: capability(),
-  closeTab: capability(),
-  click: capability(),
-  type: capability(),
-  select: capability(),
-  hover: capability(),
-  focus: capability(["mcp"]),
-  scroll: capability(),
-  press: capability(),
-  fill: capability(),
-  find: capability(),
-  check: capability(),
-  uncheck: capability(),
-  upload: capability(),
-  download: capability(["server"], "Server-only for now"),
-  dialog: capability(),
-  waitFor: capability(["mcp"]),
-  waitForNavigation: capability(["mcp"]),
-  wait: capability(["mcp"]),
-  snap: capability(),
-  screenshot: capability(),
-  html: capability(["mcp"]),
-  text: capability(["mcp"]),
-  marker: capability(),
-  markers: capability(),
-  markerGet: capability(),
-  markerRead: capability(["mcp"]),
-  markerCompare: capability(),
-  markerDelete: capability(),
-  markerResolve: capability(["cli"], "CLI-only for now"),
-  viewport: capability(),
-  colorScheme: capability(),
-  mode: capability(["mcp"]),
-  evaluate: capability(["mcp"]),
-  session: capability(),
-  sessions: capability(["mcp"]),
-  steps: capability()
-};
-function getActionsForSurface(surface) {
-  return Object.entries(ACTION_CAPABILITIES).filter(([, capability2]) => capability2.surfaces.includes(surface)).map(([action]) => action);
-}
-
-export { CAPABILITY_SURFACES, DEFAULT_ACTION_SURFACES, capability, capabilityAll, ACTION_CAPABILITIES, getActionsForSurface };

package/dist/shared/@outfitter/contracts-q0v44kef.js

@@ -1,28 +0,0 @@
-// @bun
-// packages/contracts/src/actions.ts
-var ACTION_SURFACES = ["cli", "mcp", "api", "server"];
-var DEFAULT_REGISTRY_SURFACES = ACTION_SURFACES;
-function defineAction(action) {
-  return action;
-}
-function createActionRegistry() {
-  const actions = new Map;
-  return {
-    add(action) {
-      actions.set(action.id, action);
-      return this;
-    },
-    list() {
-      return Array.from(actions.values());
-    },
-    get(id) {
-      return actions.get(id);
-    },
-    forSurface(surface) {
-      const defaults = DEFAULT_REGISTRY_SURFACES;
-      return Array.from(actions.values()).filter((action) => (action.surfaces ?? defaults).includes(surface));
-    }
-  };
-}
-
-export { ACTION_SURFACES, DEFAULT_REGISTRY_SURFACES, defineAction, createActionRegistry };

package/dist/shared/@outfitter/contracts-r21yet6j.js

@@ -1,80 +0,0 @@
-// @bun
-import {
-  TimeoutError
-} from "./contracts-phjhz5q3.js";
-
-// packages/contracts/src/resilience.ts
-import { Result } from "better-result";
-function defaultIsRetryable(error) {
-  return error.category === "network" || error.category === "timeout" || error.category === "rate_limit";
-}
-function calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter) {
-  const baseDelay = initialDelayMs * backoffMultiplier ** (attempt - 1);
-  const cappedDelay = Math.min(baseDelay, maxDelayMs);
-  if (jitter) {
-    const jitterFactor = 0.5 + Math.random();
-    return Math.floor(cappedDelay * jitterFactor);
-  }
-  return cappedDelay;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retry(fn, options) {
-  const maxAttempts = options?.maxAttempts ?? 3;
-  const initialDelayMs = options?.initialDelayMs ?? 1000;
-  const maxDelayMs = options?.maxDelayMs ?? 30000;
-  const backoffMultiplier = options?.backoffMultiplier ?? 2;
-  const jitter = options?.jitter ?? true;
-  const isRetryable = options?.isRetryable ?? defaultIsRetryable;
-  const onRetry = options?.onRetry;
-  const signal = options?.signal;
-  let lastError;
-  let attempt = 0;
-  while (attempt < maxAttempts) {
-    attempt++;
-    if (signal?.aborted) {
-      return Result.err(lastError ?? new TimeoutError({
-        message: "Operation cancelled",
-        operation: "retry",
-        timeoutMs: 0
-      }));
-    }
-    const result = await fn();
-    if (result.isOk()) {
-      return result;
-    }
-    lastError = result.error;
-    if (attempt >= maxAttempts || !isRetryable(lastError)) {
-      return result;
-    }
-    const delayMs = calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter);
-    if (onRetry) {
-      onRetry(attempt, lastError, delayMs);
-    }
-    await sleep(delayMs);
-  }
-  throw new Error("Unexpected: retry loop completed without returning a result");
-}
-async function withTimeout(fn, options) {
-  const { timeoutMs, operation = "operation" } = options;
-  let timeoutId;
-  const timeoutPromise = new Promise((resolve) => {
-    timeoutId = setTimeout(() => {
-      resolve(Result.err(new TimeoutError({
-        message: `${operation} timed out after ${timeoutMs}ms`,
-        operation,
-        timeoutMs
-      })));
-    }, timeoutMs);
-  });
-  try {
-    return await Promise.race([fn(), timeoutPromise]);
-  } finally {
-    if (timeoutId !== undefined) {
-      clearTimeout(timeoutId);
-    }
-  }
-}
-
-export { retry, withTimeout };

package/dist/shared/@outfitter/contracts-sm6vak1a.js

@@ -1,14 +0,0 @@
-// @bun
-// packages/contracts/src/logging.ts
-function createLoggerFactory(adapter) {
-  return {
-    createLogger(config) {
-      return adapter.createLogger(config);
-    },
-    async flush() {
-      await adapter.flush?.();
-    }
-  };
-}
-
-export { createLoggerFactory };

package/dist/shared/@outfitter/contracts-wfht4q2b.js

@@ -1,341 +0,0 @@
-// @bun
-// packages/contracts/src/schema.ts
-function zodToJsonSchema(schema) {
-  return convertZodType(schema);
-}
-function getDef(schemaOrDef) {
-  if (!schemaOrDef) {
-    return;
-  }
-  if (schemaOrDef._def) {
-    return schemaOrDef._def;
-  }
-  if (schemaOrDef.def) {
-    return schemaOrDef.def;
-  }
-  return schemaOrDef;
-}
-function getDescription(schema, def) {
-  if (typeof schema?.description === "string") {
-    return schema.description;
-  }
-  if (typeof def?.description === "string") {
-    return def.description;
-  }
-  return;
-}
-function convertZodType(schema) {
-  const def = getDef(schema);
-  if (!def) {
-    return {};
-  }
-  const typeName = def.typeName ?? def.type;
-  let jsonSchema;
-  switch (typeName) {
-    case "ZodString":
-    case "string":
-      jsonSchema = convertString(def);
-      break;
-    case "ZodNumber":
-    case "number":
-      jsonSchema = convertNumber(def);
-      break;
-    case "ZodBoolean":
-    case "boolean":
-      jsonSchema = { type: "boolean" };
-      break;
-    case "ZodNull":
-    case "null":
-      jsonSchema = { type: "null" };
-      break;
-    case "ZodUndefined":
-    case "undefined":
-      jsonSchema = {};
-      break;
-    case "ZodArray":
-    case "array":
-      jsonSchema = convertArray(def);
-      break;
-    case "ZodObject":
-    case "object":
-      jsonSchema = convertObject(def);
-      break;
-    case "ZodOptional":
-    case "optional":
-      jsonSchema = convertZodType(def.innerType);
-      break;
-    case "ZodNullable":
-    case "nullable":
-      jsonSchema = {
-        anyOf: [convertZodType(def.innerType), { type: "null" }]
-      };
-      break;
-    case "ZodDefault":
-    case "default": {
-      const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
-      jsonSchema = {
-        ...convertZodType(def.innerType),
-        default: defaultValue
-      };
-      break;
-    }
-    case "ZodEnum":
-    case "enum": {
-      const values = def.values ?? Object.values(def.entries ?? {});
-      jsonSchema = {
-        type: "string",
-        enum: values
-      };
-      break;
-    }
-    case "ZodNativeEnum":
-      jsonSchema = {
-        enum: Object.values(def.values ?? def.entries ?? {})
-      };
-      break;
-    case "ZodLiteral":
-    case "literal": {
-      const literalValues = Array.isArray(def.values) ? def.values : [def.value].filter((value) => value !== undefined);
-      if (literalValues.length > 1) {
-        jsonSchema = {
-          enum: literalValues
-        };
-        break;
-      }
-      jsonSchema = literalValues.length ? {
-        const: literalValues[0]
-      } : {};
-      break;
-    }
-    case "ZodUnion":
-    case "union":
-      jsonSchema = {
-        anyOf: def.options.map(convertZodType)
-      };
-      break;
-    case "ZodIntersection":
-    case "intersection":
-      jsonSchema = {
-        allOf: [convertZodType(def.left), convertZodType(def.right)]
-      };
-      break;
-    case "ZodRecord":
-    case "record":
-      jsonSchema = {
-        type: "object",
-        additionalProperties: def.valueType ? convertZodType(def.valueType) : {}
-      };
-      break;
-    case "ZodTuple":
-    case "tuple":
-      jsonSchema = {
-        type: "array",
-        items: def.items.map(convertZodType)
-      };
-      break;
-    case "ZodAny":
-    case "any":
-      jsonSchema = {};
-      break;
-    case "ZodUnknown":
-    case "unknown":
-      jsonSchema = {};
-      break;
-    case "ZodVoid":
-    case "void":
-      jsonSchema = {};
-      break;
-    case "ZodNever":
-    case "never":
-      jsonSchema = { not: {} };
-      break;
-    case "ZodEffects":
-      jsonSchema = convertZodType(def.schema);
-      break;
-    case "ZodPipeline":
-    case "pipe": {
-      const outputDef = getDef(def.out);
-      const outputType = outputDef?.typeName ?? outputDef?.type;
-      jsonSchema = outputType === "transform" ? convertZodType(def.in) : convertZodType(def.out);
-      break;
-    }
-    case "ZodLazy":
-    case "lazy":
-      jsonSchema = {};
-      break;
-    default:
-      jsonSchema = {};
-      break;
-  }
-  const description = getDescription(schema, def);
-  if (description && !jsonSchema.description) {
-    jsonSchema.description = description;
-  }
-  return jsonSchema;
-}
-function convertString(def) {
-  const schema = { type: "string" };
-  if (def.checks) {
-    for (const check of def.checks) {
-      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
-      if (normalizedCheck?.kind) {
-        switch (normalizedCheck.kind) {
-          case "min":
-            schema.minLength = normalizedCheck.value;
-            break;
-          case "max":
-            schema.maxLength = normalizedCheck.value;
-            break;
-          case "length":
-            schema.minLength = normalizedCheck.value;
-            schema.maxLength = normalizedCheck.value;
-            break;
-          case "email":
-            schema.pattern = "^[^@]+@[^@]+\\.[^@]+$";
-            break;
-          case "url":
-            schema.pattern = "^https?://";
-            break;
-          case "uuid":
-            schema.pattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
-            break;
-          case "regex":
-            schema.pattern = normalizedCheck.regex?.source ?? normalizedCheck.pattern?.source ?? (typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : undefined);
-            break;
-          default:
-            break;
-        }
-        continue;
-      }
-      if (!normalizedCheck?.check) {
-        continue;
-      }
-      switch (normalizedCheck.check) {
-        case "min_length":
-          schema.minLength = normalizedCheck.minimum;
-          break;
-        case "max_length":
-          schema.maxLength = normalizedCheck.maximum;
-          break;
-        case "string_format":
-          if (normalizedCheck.pattern) {
-            schema.pattern = typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : normalizedCheck.pattern.source;
-          }
-          if (normalizedCheck.format && normalizedCheck.format !== "regex") {
-            schema.format = normalizedCheck.format;
-          }
-          break;
-        default:
-          break;
-      }
-    }
-  }
-  return schema;
-}
-function convertNumber(def) {
-  const schema = { type: "number" };
-  if (def.checks) {
-    for (const check of def.checks) {
-      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
-      if (normalizedCheck?.kind) {
-        switch (normalizedCheck.kind) {
-          case "min":
-            schema.minimum = normalizedCheck.value;
-            break;
-          case "max":
-            schema.maximum = normalizedCheck.value;
-            break;
-          case "int":
-            schema.type = "integer";
-            break;
-          default:
-            break;
-        }
-        continue;
-      }
-      if (!normalizedCheck?.check) {
-        continue;
-      }
-      switch (normalizedCheck.check) {
-        case "greater_than":
-          if (normalizedCheck.inclusive) {
-            schema.minimum = normalizedCheck.value;
-          } else {
-            schema.exclusiveMinimum = normalizedCheck.value;
-          }
-          break;
-        case "less_than":
-          if (normalizedCheck.inclusive) {
-            schema.maximum = normalizedCheck.value;
-          } else {
-            schema.exclusiveMaximum = normalizedCheck.value;
-          }
-          break;
-        case "number_format":
-          if (normalizedCheck.format === "int" || normalizedCheck.format === "safeint") {
-            schema.type = "integer";
-          }
-          break;
-        default:
-          break;
-      }
-    }
-  }
-  return schema;
-}
-function convertArray(def) {
-  const element = def.element ?? def.type;
-  const schema = {
-    type: "array",
-    items: element ? convertZodType(element) : {}
-  };
-  return schema;
-}
-function isFieldOptional(fieldDef) {
-  if (!(fieldDef?.typeName || fieldDef?.type)) {
-    return false;
-  }
-  const typeName = fieldDef.typeName ?? fieldDef.type;
-  if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "optional" || typeName === "default") {
-    return true;
-  }
-  if (typeName === "ZodEffects") {
-    return isFieldOptional(getDef(fieldDef.schema));
-  }
-  if (typeName === "ZodPipeline" || typeName === "pipe") {
-    const inputOptional = isFieldOptional(getDef(fieldDef.in));
-    const outputDef = getDef(fieldDef.out);
-    const outputType = outputDef?.typeName ?? outputDef?.type;
-    if (outputType === "transform") {
-      return inputOptional;
-    }
-    const outputOptional = isFieldOptional(outputDef);
-    return inputOptional && outputOptional;
-  }
-  if (typeName === "ZodNullable" || typeName === "nullable") {
-    return isFieldOptional(getDef(fieldDef.innerType));
-  }
-  return false;
-}
-function convertObject(def) {
-  const properties = {};
-  const required = [];
-  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-  for (const [key, value] of Object.entries(shape ?? {})) {
-    properties[key] = convertZodType(value);
-    const fieldDef = getDef(value);
-    if (!isFieldOptional(fieldDef)) {
-      required.push(key);
-    }
-  }
-  const schema = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    schema.required = required;
-  }
-  return schema;
-}
-
-export { zodToJsonSchema };

package/dist/shared/@outfitter/contracts-zx72gyh1.js

@@ -1,32 +0,0 @@
-// @bun
-// packages/contracts/src/result/utilities.ts
-import { Result } from "better-result";
-var unwrapOrElse = (result, defaultFn) => {
-  return result.isOk() ? result.value : defaultFn(result.error);
-};
-var orElse = (result, fallback) => {
-  return result.isOk() ? result : fallback;
-};
-var combine2 = (r1, r2) => {
-  if (r1.isErr())
-    return r1;
-  if (r2.isErr())
-    return r2;
-  return Result.ok([r1.value, r2.value]);
-};
-var combine3 = (r1, r2, r3) => {
-  if (r1.isErr())
-    return r1;
-  if (r2.isErr())
-    return r2;
-  if (r3.isErr())
-    return r3;
-  return Result.ok([r1.value, r2.value, r3.value]);
-};
-var expect = (result, message) => {
-  if (result.isOk())
-    return result.value;
-  throw new Error(`${message}: ${String(result.error)}`);
-};
-
-export { unwrapOrElse, orElse, combine2, combine3, expect };

package/dist/shared/@outfitter/{contracts-3wj7xghe.js → contracts-5k6q4n48.js}

@@ -1,9 +1,4 @@
 // @bun
-import {
-  DEFAULT_PATTERNS,
-  DEFAULT_SENSITIVE_KEYS,
-  createRedactor
-} from "./contracts-s15x2rs4.js";
 import {
   AlreadyExistsError,
   AmbiguousError,
@@ -19,6 +14,11 @@ import {
   TimeoutError,
   ValidationError
 } from "./contracts-phjhz5q3.js";
+import {
+  DEFAULT_PATTERNS,
+  DEFAULT_SENSITIVE_KEYS,
+  createRedactor
+} from "./contracts-s15x2rs4.js";
 
 // packages/contracts/src/serialization.ts
 import { Result } from "better-result";