@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-ykpr0q7c.js

@@ -0,0 +1,294 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  ID9,
+  Service61,
+  node65
+} from "./repository-b5n11jz6.js";
+import {
+  NotFoundError7
+} from "./repository-3x8gcmrs.js";
+import {
+  Service60,
+  node64
+} from "./repository-1n274c67.js";
+import {
+  match2
+} from "./repository-y1fvbwt7.js";
+import {
+  Service59,
+  node63
+} from "./repository-r94mrtfv.js";
+import {
+  Service62,
+  node66
+} from "./repository-mgx963cj.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/permission.ts
+var exports_permission2 = {};
+__export(exports_permission2, {
+  AskResult: () => AskResult2,
+  AssertInput: () => AssertInput2,
+  BlockedError: () => BlockedError2,
+  CorrectedError: () => CorrectedError2,
+  DeclinedError: () => DeclinedError2,
+  Effect: () => PermissionEffect,
+  Event: () => Event13,
+  ID: () => ID7,
+  NotFoundError: () => NotFoundError6,
+  Permission: () => exports_permission2,
+  Reply: () => Reply2,
+  ReplyInput: () => ReplyInput2,
+  Request: () => Request2,
+  Rule: () => Rule3,
+  Ruleset: () => Ruleset2,
+  Service: () => Service58,
+  Source: () => Source5,
+  evaluate: () => evaluate2,
+  merge: () => merge2,
+  node: () => node62
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Deferred, Effect, Layer, Schema } from "effect";
+import { Permission } from "@opencode/schema/permission";
+import { Rule as Rule3, Ruleset as Ruleset2 } from "@opencode/schema/permission";
+import { Event as Event13 } from "@opencode/schema/permission";
+var PermissionEffect = Permission.Effect;
+var missingAgentPermissions = [{ action: "*", resource: "*", effect: "deny" }];
+var ID7 = Permission.ID;
+var Source5 = Permission.Source;
+var RequestFields = {
+  sessionID: Permission.Request.fields.sessionID,
+  action: Permission.Request.fields.action,
+  resources: Permission.Request.fields.resources,
+  save: Permission.Request.fields.save,
+  metadata: Permission.Request.fields.metadata,
+  source: Permission.Request.fields.source
+};
+var Request2 = Permission.Request;
+var Reply2 = Permission.Reply;
+var AssertInput2 = Schema.Struct({
+  id: ID7.pipe(Schema.optional),
+  ...RequestFields,
+  agent: ID9.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.AssertInput" });
+var ReplyInput2 = Schema.Struct({
+  requestID: ID7,
+  reply: Reply2,
+  message: Schema.String.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.ReplyInput" });
+var AskResult2 = Schema.Struct({
+  id: ID7,
+  effect: Permission.Effect
+}).annotate({ identifier: "Permission.AskResult" });
+
+class DeclinedError2 extends Schema.TaggedError()("Permission.DeclinedError", {}) {
+}
+
+class CorrectedError2 extends Schema.TaggedError()("Permission.CorrectedError", {
+  feedback: Schema.String
+}) {
+}
+
+class BlockedError2 extends Schema.TaggedError()("Permission.BlockedError", {
+  rules: Permission.Ruleset,
+  permission: Schema.String,
+  resources: Schema.Array(Schema.String),
+  reason: Schema.String.pipe(Schema.optional)
+}) {
+  get message() {
+    return this.reason ?? `Permission denied: ${this.permission}`;
+  }
+}
+
+class NotFoundError6 extends Schema.TaggedError()("Permission.NotFoundError", {
+  requestID: ID7
+}) {
+}
+function evaluate2(action, resource, ...rulesets) {
+  return rulesets.flat().findLast((rule) => match2(action, rule.action) && match2(resource, rule.resource)) ?? {
+    action,
+    resource: "*",
+    effect: "ask"
+  };
+}
+function merge2(...rulesets) {
+  return rulesets.flat();
+}
+
+class Service58 extends Context.Service()("@opencode/Permission") {
+}
+var layer = Layer.effect(Service58, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const location = yield* Service66;
+  const agents = yield* Service61;
+  const sessions = yield* Service60;
+  const saved = yield* Service59;
+  const hooks = yield* Service62;
+  const pending = new Map;
+  yield* Effect.addFinalizer(() => Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new DeclinedError2), {
+    discard: true
+  }).pipe(Effect.ensuring(Effect.sync(() => {
+    pending.clear();
+  }))));
+  const savedRules = Effect.fnUntraced(function* () {
+    return (yield* saved.list({ projectID: location.project.id })).map((item) => ({
+      action: item.action,
+      resource: item.resource,
+      effect: "allow"
+    }));
+  });
+  const configured = Effect.fnUntraced(function* (sessionID, agentID) {
+    const session = yield* sessions.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError7({ sessionID });
+    const agent = yield* agents.resolve(agentID ?? session.agent);
+    return merge2(agent?.permissions ?? missingAgentPermissions, session.permissions ?? []);
+  });
+  function denied(input, rules) {
+    return input.resources.some((resource) => evaluate2(input.action, resource, rules).effect === "deny");
+  }
+  function relevant(input, rules) {
+    return rules.filter((rule) => match2(input.action, rule.action));
+  }
+  const evaluateInput = Effect.fnUntraced(function* (input) {
+    const rules = yield* configured(input.sessionID, input.agent);
+    if (denied(input, rules))
+      return { effect: "deny", rules };
+    const all = [...rules, ...yield* savedRules()];
+    const effects = input.resources.map((resource) => evaluate2(input.action, resource, all).effect);
+    const effect = effects.includes("ask") ? "ask" : "allow";
+    const event = yield* hooks.trigger("permission", "evaluate", {
+      sessionID: input.sessionID,
+      agent: input.agent,
+      action: input.action,
+      resources: input.resources,
+      metadata: input.metadata,
+      source: input.source,
+      effect
+    });
+    return { effect: event.effect, message: event.message, rules: all };
+  });
+  function request(input, message) {
+    return {
+      id: input.id ?? ID7.create(),
+      sessionID: input.sessionID,
+      action: input.action,
+      resources: input.resources,
+      save: input.save,
+      metadata: input.metadata,
+      source: input.source,
+      message
+    };
+  }
+  const create = (request, agent) => Effect.uninterruptible(Effect.gen(function* () {
+    const deferred = yield* Deferred.make();
+    const item = { request, agent, deferred };
+    if (pending.has(request.id))
+      return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request.id}`));
+    pending.set(request.id, item);
+    yield* bus.publish(Permission.Event.Asked, request).pipe(Effect.onError(() => Effect.sync(() => pending.delete(request.id))));
+    return item;
+  }));
+  const ask = Effect.fn("Permission.ask")(function* (input) {
+    const result = yield* evaluateInput(input);
+    const value = request(input, result.message);
+    if (result.effect === "ask")
+      yield* create(value, input.agent);
+    return { id: value.id, effect: result.effect };
+  });
+  const assert = Effect.fn("Permission.assert")((input) => Effect.gen(function* () {
+    const result = yield* evaluateInput(input);
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      if (result.effect === "deny") {
+        return yield* new BlockedError2({
+          rules: relevant(input, result.rules),
+          permission: input.action,
+          resources: input.resources,
+          reason: result.message
+        });
+      }
+      if (result.effect === "allow")
+        return;
+      const item = yield* create(request(input, result.message), input.agent);
+      return yield* restore(Deferred.await(item.deferred)).pipe(Effect.catchTag("Permission.DeclinedError", (error) => Effect.die(error)), Effect.ensuring(Effect.sync(() => {
+        pending.delete(item.request.id);
+      })));
+    }));
+  }));
+  const reply = Effect.fn("Permission.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const existing = pending.get(input.requestID);
+    if (!existing)
+      return yield* new NotFoundError6({ requestID: input.requestID });
+    yield* bus.publish(Permission.Event.Replied, {
+      sessionID: existing.request.sessionID,
+      requestID: existing.request.id,
+      reply: input.reply
+    });
+    if (input.reply === "reject") {
+      yield* Deferred.fail(existing.deferred, input.message ? new CorrectedError2({ feedback: input.message }) : new DeclinedError2);
+      pending.delete(input.requestID);
+      for (const [id, item] of pending) {
+        if (item.request.sessionID !== existing.request.sessionID)
+          continue;
+        yield* bus.publish(Permission.Event.Replied, {
+          sessionID: item.request.sessionID,
+          requestID: item.request.id,
+          reply: "reject"
+        });
+        yield* Deferred.fail(item.deferred, new DeclinedError2);
+        pending.delete(id);
+      }
+      return;
+    }
+    if (input.reply === "always" && existing.request.save?.length) {
+      yield* saved.add({
+        projectID: location.project.id,
+        action: existing.request.action,
+        resources: existing.request.save
+      });
+    }
+    yield* Deferred.succeed(existing.deferred, undefined);
+    pending.delete(input.requestID);
+    if (input.reply !== "always" || !existing.request.save?.length)
+      return;
+    for (const [id, item] of pending) {
+      const result = yield* evaluateInput({ ...item.request, agent: item.agent }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.undefined));
+      if (result?.effect !== "allow")
+        continue;
+      yield* bus.publish(Permission.Event.Replied, {
+        sessionID: item.request.sessionID,
+        requestID: item.request.id,
+        reply: "always"
+      });
+      yield* Deferred.succeed(item.deferred, undefined);
+      pending.delete(id);
+    }
+  })));
+  const list = Effect.fn("Permission.list")(function* () {
+    return Array.from(pending.values(), (item) => item.request);
+  });
+  const get = Effect.fn("Permission.get")(function* (id) {
+    return pending.get(id)?.request;
+  });
+  const forSession = Effect.fn("Permission.forSession")(function* (sessionID) {
+    return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID);
+  });
+  return Service58.of({ ask, assert, reply, get, forSession, list });
+}));
+var node62 = makeLocationNode({
+  service: Service58,
+  layer,
+  deps: [node83, node70, node65, node64, node63, node66]
+});
+
+export { PermissionEffect, ID7, Source5, Request2, Reply2, AssertInput2, ReplyInput2, AskResult2, DeclinedError2, CorrectedError2, BlockedError2, NotFoundError6, evaluate2, merge2, Service58, node62, exports_permission2, Rule3, Ruleset2, Event13 };

package/dist/chunks/repository-ym463w8f.js

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin2(input) {
+  return define({
+    id: input.id,
+    effect: Effect.fn(function* (ctx) {
+      yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+        if (evt.package !== input.package)
+          return;
+        evt.sdk = yield* Effect.promise(() => input.load(evt.options));
+      }));
+    })
+  });
+}
+
+export { createProviderPlugin2 };

package/dist/chunks/repository-yrhqyw5v.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./repository-ym463w8f.js";
+
+// src/plugin/provider/venice.ts
+var VenicePlugin2 = createProviderPlugin2({
+  id: "opencode.provider.venice",
+  package: "venice-ai-sdk-provider",
+  load: async (options) => {
+    const { createVenice } = await import("venice-ai-sdk-provider");
+    return createVenice(options);
+  }
+});
+
+export { VenicePlugin2 };

package/dist/chunks/repository-yrznvahk.js

@@ -0,0 +1,60 @@
+import {
+  InvalidError2
+} from "./repository-z63w68vq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/variable.ts
+var exports_variable = {};
+__export(exports_variable, {
+  ConfigVariable: () => exports_variable,
+  substitute: () => substitute2
+});
+import os from "os";
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+var substitute2 = Effect.fn("ConfigVariable.substitute")(function* (input) {
+  const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
+  if (!text.includes("{file:"))
+    return text;
+  return yield* substituteFiles(input, text);
+});
+var substituteFiles = Effect.fnUntraced(function* (input, text) {
+  const fs = yield* FSUtil.Service;
+  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir;
+  const configSource = input.type === "path" ? input.path : input.source;
+  let out = "";
+  let cursor = 0;
+  for (const match of text.matchAll(/\{file:[^}]+\}/g)) {
+    const token = match[0];
+    const index = match.index;
+    out += text.slice(cursor, index);
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      out += token;
+      cursor = index + token.length;
+      continue;
+    }
+    const filePath = token.slice("{file:".length, -1);
+    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath);
+    const fileContent = yield* fs.readFileString(resolvedPath).pipe(Effect.catch((error) => {
+      if (input.missing === "empty")
+        return Effect.succeed("");
+      const message = `bad file reference: "${token}"`;
+      return Effect.fail(new InvalidError2({
+        path: configSource,
+        message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
+      }, { cause: error }));
+    }));
+    out += JSON.stringify(fileContent.trim()).slice(1, -1);
+    cursor = index + token.length;
+  }
+  return out + text.slice(cursor);
+});
+
+export { substitute2, exports_variable };

package/dist/chunks/repository-yz39bey7.js

@@ -0,0 +1,310 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/form.ts
+var exports_form = {};
+__export(exports_form, {
+  AlreadyExistsError: () => AlreadyExistsError2,
+  AlreadySettledError: () => AlreadySettledError2,
+  Answer: () => Answer2,
+  Event: () => Event20,
+  Field: () => Field2,
+  Fields: () => Fields2,
+  Form: () => exports_form,
+  ID: () => ID18,
+  Info: () => Info33,
+  InvalidAnswerError: () => InvalidAnswerError2,
+  InvalidFormError: () => InvalidFormError2,
+  NotFoundError: () => NotFoundError10,
+  Reply: () => Reply3,
+  Service: () => Service77,
+  State: () => State3,
+  When: () => When2,
+  layer: () => layer25,
+  node: () => node82,
+  validateAnswer: () => validateAnswer2,
+  validateFields: () => validateFields2
+});
+import { Form } from "@opencode/schema/form";
+import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Event as Event20 } from "@opencode/schema/form";
+var RETENTION = Duration.minutes(10);
+var ID18 = Form.ID;
+var Info33 = Form.Info;
+var Field2 = Form.Field;
+var Fields2 = Form.Fields;
+var When2 = Form.When;
+var State3 = Form.State;
+var Answer2 = Form.Answer;
+var Reply3 = Form.Reply;
+
+class NotFoundError10 extends Schema.TaggedError()("Form.NotFoundError", {
+  id: ID18
+}) {
+  get message() {
+    return `Form not found: ${this.id}`;
+  }
+}
+
+class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
+  id: ID18
+}) {
+  get message() {
+    return `Form already settled: ${this.id}`;
+  }
+}
+
+class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
+  id: ID18
+}) {
+  get message() {
+    return `Form already exists: ${this.id}`;
+  }
+}
+
+class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
+  id: ID18,
+  message: Schema.String
+}) {
+}
+
+class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
+  message: Schema.String
+}) {
+}
+
+class Service77 extends Context.Service()("@opencode/Form") {
+}
+var layer25 = Layer.effect(Service77, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
+    capacity: Number.MAX_SAFE_INTEGER,
+    timeToLive: (exit) => Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION
+  });
+  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError10({ id })))));
+  const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const id = input.id ?? ID18.create();
+    const existing = yield* Cache.getSuccess(forms, id);
+    if (Option.isSome(existing))
+      return yield* new AlreadyExistsError2({ id });
+    const invalid = validateFields2(input.fields);
+    if (invalid)
+      return yield* new InvalidFormError2({ message: invalid });
+    const form = {
+      id,
+      sessionID: input.sessionID,
+      title: input.title,
+      ...input.metadata === undefined ? {} : { metadata: input.metadata },
+      fields: input.fields
+    };
+    const entry = {
+      form,
+      state: { status: "pending" },
+      deferred: yield* Deferred.make()
+    };
+    yield* Cache.set(forms, id, entry);
+    yield* bus.publish(Form.Event.Created, { form }).pipe(Effect.onError(() => Cache.invalidate(forms, id)));
+    return form;
+  })));
+  const ask = Effect.fn("Form.ask")((input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const form = yield* create(input);
+    const entry = yield* requireEntry(form.id).pipe(Effect.orDie);
+    return yield* restore(Deferred.await(entry.deferred)).pipe(Effect.onInterrupt(() => Effect.ignore(cancel(form.id))));
+  })));
+  const get = Effect.fn("Form.get")(function* (id) {
+    return (yield* requireEntry(id)).form;
+  });
+  const list = Effect.fn("Form.list")(function* (input) {
+    const entries = yield* Cache.values(forms);
+    return Array.from(entries).filter((entry) => entry.state.status === "pending").filter((entry) => input?.sessionID === undefined || entry.form.sessionID === input.sessionID).map((entry) => entry.form);
+  });
+  const state = Effect.fn("Form.state")(function* (id) {
+    return (yield* requireEntry(id)).state;
+  });
+  const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* requireEntry(input.id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ id: input.id });
+    const invalid = validateAnswer2(entry.form.fields, input.answer);
+    if (invalid)
+      return yield* new InvalidAnswerError2({ id: input.id, message: invalid });
+    const next = { status: "answered", answer: input.answer };
+    yield* bus.publish(Form.Event.Replied, {
+      id: input.id,
+      sessionID: entry.form.sessionID,
+      answer: input.answer
+    });
+    yield* Cache.set(forms, input.id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  const cancel = Effect.fn("Form.cancel")((id) => Effect.uninterruptible(Effect.gen(function* () {
+    const entry = yield* requireEntry(id);
+    if (entry.state.status !== "pending")
+      return yield* new AlreadySettledError2({ id });
+    const next = { status: "cancelled" };
+    yield* bus.publish(Form.Event.Cancelled, { id, sessionID: entry.form.sessionID });
+    yield* Cache.set(forms, id, { ...entry, state: next });
+    yield* Deferred.succeed(entry.deferred, next);
+  })));
+  yield* Effect.addFinalizer(() => Cache.values(forms).pipe(Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true }))));
+  return Service77.of({ create, ask, get, list, state, reply, cancel });
+}));
+var node82 = makeLocationNode({ service: Service77, layer: layer25, deps: [node83] });
+function validateAnswer2(form, answer) {
+  const fields = new Map(form.map((field) => [field.key, field]));
+  for (const key of Object.keys(answer)) {
+    if (!fields.has(key))
+      return `Unknown form field: ${key}`;
+  }
+  for (const field of form) {
+    const value = answer[field.key];
+    if (field.type === "external") {
+      if (value !== true)
+        return `External form field must be acknowledged: ${field.key}`;
+      continue;
+    }
+    const active = isActive(field, answer);
+    if (value === undefined) {
+      if (field.required && active)
+        return `Missing required form field: ${field.key}`;
+      continue;
+    }
+    if (!active)
+      return `Form field is not active: ${field.key}`;
+    const invalid = validateField(field, value);
+    if (invalid)
+      return invalid;
+  }
+}
+function isActive(field, answer) {
+  if (!field.when)
+    return true;
+  return field.when.every((when) => matches(when, answer[when.key]));
+}
+function matches(when, value) {
+  if (value === undefined)
+    return false;
+  const hit = Array.isArray(value) ? value.some((item) => item === when.value) : value === when.value;
+  return when.op === "eq" ? hit : !hit;
+}
+function validateFields2(fields) {
+  if (fields.length === 0)
+    return "Form must have at least one field";
+  const earlier = new Map;
+  const keys = new Set;
+  for (const field of fields) {
+    if (keys.has(field.key))
+      return `Duplicate form field key: ${field.key}`;
+    keys.add(field.key);
+    if (field.type === "external")
+      continue;
+    for (const when of field.when ?? []) {
+      const target = earlier.get(when.key);
+      if (!target)
+        return `Form field condition must reference an earlier field: ${field.key} -> ${when.key}`;
+      const invalid = validateWhen(when, target);
+      if (invalid)
+        return `${invalid}: ${field.key} -> ${when.key}`;
+    }
+    earlier.set(field.key, field);
+  }
+}
+function validateWhen(when, target) {
+  if (target.type === "boolean") {
+    if (typeof when.value !== "boolean")
+      return "Form field condition value must be a boolean";
+    return;
+  }
+  if (target.type === "number" || target.type === "integer") {
+    if (typeof when.value !== "number")
+      return "Form field condition value must be a number";
+    return;
+  }
+  if (typeof when.value !== "string")
+    return "Form field condition value must be a string";
+  const closed = target.type === "multiselect" ? !target.custom : target.options !== undefined && !target.custom;
+  if (closed && !target.options?.some((option) => option.value === when.value)) {
+    return "Form field condition value must be one of the field's options";
+  }
+}
+function validateField(field, value) {
+  if (field.type === "string") {
+    if (typeof value !== "string")
+      return `Expected string for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minLength !== undefined && value.length < field.minLength)
+      return `Form field is too short: ${field.key}`;
+    if (field.maxLength !== undefined && value.length > field.maxLength)
+      return `Form field is too long: ${field.key}`;
+    if (field.pattern !== undefined) {
+      try {
+        if (!new RegExp(field.pattern).test(value))
+          return `Form field does not match pattern: ${field.key}`;
+      } catch {
+        return `Form field has invalid pattern: ${field.key}`;
+      }
+    }
+    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+      return `Expected email for form field: ${field.key}`;
+    if (field.format === "uri" && !URL.canParse(value))
+      return `Expected URI for form field: ${field.key}`;
+    if (field.format === "date" && !isDate(value))
+      return `Expected date for form field: ${field.key}`;
+    if (field.format === "date-time" && !isDateTime(value))
+      return `Expected date-time for form field: ${field.key}`;
+    if (field.options && !field.custom && !field.options.some((option) => option.value === value)) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+    return;
+  }
+  if (field.type === "number" || field.type === "integer") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return `Expected number for form field: ${field.key}`;
+    if (field.type === "integer" && !Number.isInteger(value))
+      return `Expected integer for form field: ${field.key}`;
+    if (field.minimum !== undefined && value < field.minimum)
+      return `Form field is too small: ${field.key}`;
+    if (field.maximum !== undefined && value > field.maximum)
+      return `Form field is too large: ${field.key}`;
+    return;
+  }
+  if (field.type === "boolean") {
+    if (typeof value !== "boolean")
+      return `Expected boolean for form field: ${field.key}`;
+    return;
+  }
+  if (field.type === "multiselect") {
+    if (!isStringArray(value))
+      return `Expected string array for form field: ${field.key}`;
+    if (field.required && value.length === 0)
+      return `Missing required form field: ${field.key}`;
+    if (field.minItems !== undefined && value.length < field.minItems)
+      return `Too few selections for form field: ${field.key}`;
+    if (field.maxItems !== undefined && value.length > field.maxItems)
+      return `Too many selections for form field: ${field.key}`;
+    if (!field.custom && value.some((item) => !field.options.some((option) => option.value === item))) {
+      return `Invalid option for form field: ${field.key}`;
+    }
+  }
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function isDateTime(value) {
+  return !Number.isNaN(new Date(value).getTime());
+}
+
+export { ID18, Info33, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError10, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service77, layer25, node82, validateAnswer2, validateFields2, exports_form, Event20 };