@opencode/core 2.0.31 → 2.1.0

package/dist/types/config/discovery.d.ts

@@ -30,12 +30,12 @@ export declare function preferencePaths(user: string): (string & import("effect/
 /** Removes MDM payload metadata from `plutil -convert json` output. */
 export declare function stripPreferenceMetadata(json: string): string;
 export declare const discover: (options?: {
-    readonly global?: boolean | undefined;
     readonly project?: boolean | undefined;
+    readonly global?: boolean | undefined;
     readonly system?: string | boolean | undefined;
+    readonly claude?: boolean | undefined;
     readonly file?: string | undefined;
     readonly content?: string | undefined;
-    readonly claude?: boolean | undefined;
 } | undefined) => Effect.Effect<{
     system: {
         path: string & import("effect/Brand").Brand<"AbsolutePath">;

package/dist/types/config/plugin/entry-observer.d.ts

@@ -3,5 +3,5 @@ import type { EventDomain } from "@opencode/plugin/effect/event";
 import { Effect } from "effect";
 import { Config } from "../../config.js";
 export declare const observe: (config: Config.Interface, event: EventDomain, reload: Effect.Effect<void, never, never>) => Effect.Effect<{
-    entries: (import("@opencode/schema/config").Document | import("@opencode/schema/config").Directory)[];
+    entries: (import("@opencode/schema/config").Directory | import("@opencode/schema/config").Document)[];
 }, never, import("effect/Scope").Scope>;

package/dist/types/config/plugin/instruction.d.ts

@@ -6,4 +6,4 @@ import { Config } from "../../config.js";
 import { Watcher } from "../../filesystem/watcher.js";
 import { InstructionDiscovery } from "../../instruction-discovery.js";
 import { Location } from "../../location.js";
-export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | Global.Service | HttpClient.HttpClient | FSUtil.Service | Location.Service | Watcher.Service | Config.Service | InstructionDiscovery.Service>;
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<HttpClient.HttpClient | import("effect/Scope").Scope | Global.Service | FSUtil.Service | Location.Service | Watcher.Service | Config.Service | InstructionDiscovery.Service>;

package/dist/types/config/plugin/skill-scan.d.ts

@@ -0,0 +1,5 @@
+export * as SkillScan from "./skill-scan.js";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Effect } from "effect";
+export declare const ignore: string[];
+export declare const scan: (root: string) => Effect.Effect<string[], never, FSUtil.Service>;

package/dist/types/config.d.ts

@@ -54,6 +54,6 @@ export declare const testLayer: (initial?: Entry[], compatibility?: {
     readonly claude: readonly AbsolutePath[];
     readonly agents: readonly AbsolutePath[];
 }) => Layer.Layer<Service | Test, never, never>;
-export declare const layer: (options?: Options) => Layer.Layer<Service, never, Global.Service | FSUtil.Service | AppProcess.Service | Bus.Service | Location.Service | Credential.Service | Watcher.Service | WellKnown.Service>;
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Global.Service | FSUtil.Service | AppProcess.Service | Location.Service | Bus.Service | Credential.Service | Watcher.Service | WellKnown.Service>;
 export declare function configured(options?: Options): import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/credential/sql.d.ts

@@ -101,9 +101,6 @@ export declare const CredentialTable: import("drizzle-orm/sqlite-core").SQLiteTa
                 readonly metadata?: {
                     readonly [x: string]: unknown;
                 } | undefined;
-                readonly configuration?: {
-                    readonly [x: string]: string | number | boolean | readonly string[];
-                } | undefined;
             } | {
                 readonly type: "external";
                 readonly methodID: string & import("effect/Brand").Brand<"Integration.MethodID">;
@@ -171,5 +168,5 @@ export declare const CredentialTable: import("drizzle-orm/sqlite-core").SQLiteTa
             generated: undefined;
         }, {}>;
     };
-    dialect: "sqlite";
+    dialect: 'sqlite';
 }>;

package/dist/types/credential.d.ts

@@ -19,7 +19,6 @@ export declare const Key: Schema.Struct<{
     readonly type: Schema.Literal<"key">;
     readonly key: Schema.String;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
 }>;
 export type Key = Credential.Key;
 export declare const External: Schema.Struct<{
@@ -39,7 +38,6 @@ export declare const Value: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"key">;
     readonly key: Schema.String;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"external">;
     readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
@@ -216,7 +214,6 @@ declare const Info_base: Schema.Class<Info, Schema.Struct<{
         readonly type: Schema.Literal<"key">;
         readonly key: Schema.String;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"external">;
         readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;

package/dist/types/database/drizzle/effect-sqlite/driver.d.ts

@@ -34,7 +34,7 @@ export declare const DefaultServices: Layer.Layer<EffectCache | EffectLogger, ne
  */
 export declare const make: <TRelations extends AnyRelations = EmptyRelations>(config?: EffectDrizzleSQLiteConfig<TRelations> | undefined) => Effect.Effect<EffectSQLiteDatabase<TRelations> & {
     $client: SqlClient;
-}, never, SqlClient | EffectCache | EffectLogger>;
+}, never, EffectCache | EffectLogger | SqlClient>;
 /**
  * Convenience function that creates an EffectSQLiteDatabase with `DefaultServices` already provided.
  */

package/dist/types/database/migration/20260805200742_import_legacy_credentials.d.ts

@@ -2,4 +2,4 @@ import { Effect } from "effect";
 import type { DatabaseMigration } from "../migration.js";
 declare const migration: DatabaseMigration.Migration;
 export default migration;
-export declare function importLegacyCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], filepath: string): Effect.Effect<undefined, Error | import("drizzle-orm/effect-core").EffectDrizzleQueryError, never>;
+export declare function importLegacyCredentials(tx: Parameters<DatabaseMigration.Migration["up"]>[0], filepath: string): Effect.Effect<undefined, import("drizzle-orm/effect-core").EffectDrizzleQueryError | Error, never>;

package/dist/types/database/path.d.ts

@@ -1,67 +1,67 @@
 export declare const absoluteColumn: {
     (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string & import("effect/Brand").Brand<"AbsolutePath">;
         driverParam: string;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+    <TConfig extends Record<string, any> & unknown>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: 'custom';
         data: string & import("effect/Brand").Brand<"AbsolutePath">;
         driverParam: string;
     }>;
     (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string & import("effect/Brand").Brand<"AbsolutePath">;
         driverParam: string;
     }>;
 };
 export declare const directoryColumn: {
     (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+    <TConfig extends Record<string, any> & unknown>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
     (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
 };
 export declare const pathColumn: {
     (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+    <TConfig extends Record<string, any> & unknown>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
     (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: string;
         driverParam: string;
     }>;
 };
 export declare const absoluteArrayColumn: {
     (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
         driverParam: string;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+    <TConfig extends Record<string, any> & unknown>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        dataType: 'custom';
         data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
         driverParam: string;
     }>;
     (dbname: string, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-        dataType: "custom";
+        dataType: 'custom';
         data: (string & import("effect/Brand").Brand<"AbsolutePath">)[];
         driverParam: string;
     }>;

package/dist/types/database/sqlite.bun.d.ts

@@ -10,5 +10,5 @@ interface Config extends Sqlite.ClientConfig {
     readonly readwrite?: boolean;
     readonly disableWAL?: boolean;
 }
-export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export declare const sqliteLayer: (config: Config) => Layer.Layer<Sqlite.Native | SqlClient.SqlClient, never, never>;
 export {};

package/dist/types/database/sqlite.node.d.ts

@@ -12,5 +12,5 @@ interface Config extends Sqlite.ClientConfig {
     readonly timeout?: number;
     readonly allowExtension?: boolean;
 }
-export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export declare const sqliteLayer: (config: Config) => Layer.Layer<Sqlite.Native | SqlClient.SqlClient, never, never>;
 export {};

package/dist/types/database/sqlite.workerd.d.ts

@@ -25,5 +25,5 @@ interface Config {
     readonly transformResultNames?: (str: string) => string;
     readonly transformQueryNames?: (str: string) => string;
 }
-export declare const sqliteLayer: (config: Config) => Layer.Layer<SqlClient.SqlClient | Sqlite.Native, never, never>;
+export declare const sqliteLayer: (config: Config) => Layer.Layer<Sqlite.Native | SqlClient.SqlClient, never, never>;
 export {};

package/dist/types/effect/websocket-constructor.d.ts

@@ -1,8 +1,9 @@
 import { Layer } from "effect";
 import { Socket } from "effect/socket";
 type Environment = Readonly<Record<string, string | undefined>>;
+declare const proxy: (value: string, environment?: Environment) => string | undefined;
 export declare const WebSocketConstructor: {
     readonly layer: Layer.Layer<Socket.WebSocketConstructor, never, never>;
-    readonly proxy: (value: string, environment?: Environment) => string | undefined;
+    readonly proxy: typeof proxy;
 };
 export {};

package/dist/types/environment/files.d.ts

@@ -56,5 +56,5 @@ export interface Files extends FilesImpl {
  * Derives a follow-stat kind from the lstat-like Files contract. A dangling
  * symlink fails with `NotFound`.
  */
-export declare const typeFollowing: (files: Files, path: string) => Effect.Effect<"directory" | "file" | "symlink" | "other", NotFound | Failed, never>;
+export declare const typeFollowing: (files: Files, path: string) => Effect.Effect<"directory" | "file" | "other" | "symlink", Failed | NotFound, never>;
 export * as EnvironmentFiles from "./files.js";

package/dist/types/event/sql.d.ts

@@ -51,7 +51,7 @@ export declare const EventSequenceTable: import("drizzle-orm/sqlite-core").SQLit
             generated: undefined;
         }, {}>;
     };
-    dialect: "sqlite";
+    dialect: 'sqlite';
 }>;
 export declare const EventTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "event";
@@ -154,5 +154,5 @@ export declare const EventTable: import("drizzle-orm/sqlite-core").SQLiteTableWi
             generated: undefined;
         }, {}>;
     };
-    dialect: "sqlite";
+    dialect: 'sqlite';
 }>;

package/dist/types/file-mutation.d.ts

@@ -1,6 +1,7 @@
 export * as FileMutation from "./file-mutation.js";
 import { Context, Effect } from "effect";
 import { Environment } from "./environment/index.js";
+import type { Files } from "./environment/index.js";
 import type { FileAccess } from "./file-access.js";
 export type Target = Pick<FileAccess.Target, "absolute" | "resource">;
 export interface WriteInput {
@@ -27,11 +28,11 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/FileMutation", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const readText: (files: Environment.Files, target: string) => Effect.Effect<{
+export declare const readText: (files: Files, target: string) => Effect.Effect<{
     bom: boolean;
     text: string;
-}, Environment.NotFound | Environment.WrongKind | Environment.Failed, never>;
-export declare const syncTextBom: (files: Environment.Files, target: string, bom: boolean) => Effect.Effect<string, Environment.NotFound | Environment.WrongKind | Environment.Failed, never>;
+}, Environment.Failed | Environment.NotFound | Environment.WrongKind, never>;
+export declare const syncTextBom: (files: Files, target: string, bom: boolean) => Effect.Effect<string, Environment.Failed | Environment.NotFound | Environment.WrongKind, never>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
 /**
  * Deferred until the corresponding integrations exist.

package/dist/types/filesystem.d.ts

@@ -164,4 +164,4 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/FileSystem", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, DirectoryNotFoundError | DirectoryAccessDeniedError, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, DirectoryAccessDeniedError | DirectoryNotFoundError, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/form.d.ts

@@ -7,7 +7,27 @@ export declare const ID: Schema.brand<Schema.String, "Form.ID"> & {
 };
 export type ID = typeof ID.Type;
 export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly sessionID: Schema.String;
+    readonly title: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
     readonly fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
         readonly type: Schema.Literal<"string">;
         readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
         readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
@@ -25,6 +45,7 @@ export declare const Info: Schema.Struct<{
             readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         }>>>, never, never>;
         readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>, Schema.Struct<{
         readonly key: Schema.String;
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -39,11 +60,11 @@ export declare const Info: Schema.Struct<{
             readonly op: Schema.Literals<readonly ["eq", "neq"]>;
             readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
         }>>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.Literal<"number">;
         readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
         readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
         readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    }>, Schema.Struct<{
         readonly key: Schema.String;
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -58,11 +79,11 @@ export declare const Info: Schema.Struct<{
             readonly op: Schema.Literals<readonly ["eq", "neq"]>;
             readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
         }>>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.Literal<"integer">;
         readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
         readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
         readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    }>, Schema.Struct<{
         readonly key: Schema.String;
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -77,9 +98,9 @@ export declare const Info: Schema.Struct<{
             readonly op: Schema.Literals<readonly ["eq", "neq"]>;
             readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
         }>>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.Literal<"boolean">;
         readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>, Schema.Struct<{
         readonly key: Schema.String;
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -94,7 +115,6 @@ export declare const Info: Schema.Struct<{
             readonly op: Schema.Literals<readonly ["eq", "neq"]>;
             readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
         }>>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.Literal<"multiselect">;
         readonly options: Schema.$Array<Schema.Struct<{
             readonly value: Schema.String;
@@ -105,20 +125,6 @@ export declare const Info: Schema.Struct<{
         readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
-        readonly key: Schema.String;
-        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
-        }>>>, never, never>;
     }>, Schema.Struct<{
         readonly key: Schema.String;
         readonly type: Schema.Literal<"external">;
@@ -126,15 +132,23 @@ export declare const Info: Schema.Struct<{
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>]>>;
-    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-    };
-    readonly sessionID: Schema.String;
-    readonly title: Schema.String;
-    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
 }>;
 export type Info = typeof Info.Type;
 export declare const Field: Schema.Union<readonly [Schema.Struct<{
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
     readonly type: Schema.Literal<"string">;
     readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
     readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
@@ -152,6 +166,7 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>>>, never, never>;
     readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -166,11 +181,11 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"number">;
     readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -185,11 +200,11 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"integer">;
     readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -204,9 +219,9 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"boolean">;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -221,7 +236,6 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"multiselect">;
     readonly options: Schema.$Array<Schema.Struct<{
         readonly value: Schema.String;
@@ -232,6 +246,15 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
     readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly type: Schema.Literal<"external">;
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type Field = Form.Field;
+export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -246,15 +269,6 @@ export declare const Field: Schema.Union<readonly [Schema.Struct<{
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
-    readonly key: Schema.String;
-    readonly type: Schema.Literal<"external">;
-    readonly url: Schema.String;
-    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>]>;
-export type Field = Form.Field;
-export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"string">;
     readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
     readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
@@ -272,6 +286,7 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>>>, never, never>;
     readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -286,11 +301,11 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"number">;
     readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -305,11 +320,11 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"integer">;
     readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -324,9 +339,9 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"boolean">;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, Schema.Struct<{
     readonly key: Schema.String;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -341,7 +356,6 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
         readonly op: Schema.Literals<readonly ["eq", "neq"]>;
         readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
     }>>>, never, never>;
-}>, Schema.Struct<{
     readonly type: Schema.Literal<"multiselect">;
     readonly options: Schema.$Array<Schema.Struct<{
         readonly value: Schema.String;
@@ -352,20 +366,6 @@ export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.
     readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
-    readonly key: Schema.String;
-    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
-    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
-    }>>>, never, never>;
 }>, Schema.Struct<{
     readonly key: Schema.String;
     readonly type: Schema.Literal<"external">;