@opencode-ai/schema 0.0.0-dev-17471

package/dist/form.js

@@ -0,0 +1,120 @@
+export * as Form from "./form.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { ascending } from "./identifier.js";
+import { NonNegativeInt, optional, statics } from "./schema.js";
+const IDSchema = Schema.String.check(Schema.isStartsWith("frm_")).pipe(Schema.brand("Form.ID"));
+export const ID = IDSchema.pipe(statics((schema) => ({ create: (id) => schema.make(id ?? "frm_" + ascending()) })));
+export const Metadata = Schema.Record(Schema.String, Schema.Unknown).annotate({ identifier: "Form.Metadata" });
+export const Option = Schema.Struct({
+    value: Schema.String,
+    label: Schema.String,
+    description: Schema.String.pipe(optional),
+}).annotate({ identifier: "Form.Option" });
+// One visibility condition on a field. A field's `when` is a list of conditions that must all
+// hold (AND) against the current answers for the field to be active. Semantics:
+// - `value` must match the referenced field's type; against a multiselect answer, `eq` means
+//   "selection includes value" and `neq` means "selection does not include value".
+// - An unanswered referenced field makes the condition false for both ops.
+// - `key` must reference a field defined earlier in the form's field list.
+// Inactive fields are neither required nor answerable.
+export const When = Schema.Struct({
+    key: Schema.String,
+    op: Schema.Literals(["eq", "neq"]),
+    value: Schema.Union([Schema.String, Schema.Number, Schema.Boolean]),
+}).annotate({ identifier: "Form.When" });
+const FieldBase = {
+    key: Schema.String,
+    title: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    required: Schema.Boolean.pipe(optional),
+    when: Schema.Array(When).pipe(optional),
+};
+export const StringField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("string"),
+    format: Schema.Literals(["email", "uri", "date", "date-time"]).pipe(optional),
+    minLength: NonNegativeInt.pipe(optional),
+    maxLength: NonNegativeInt.pipe(optional),
+    pattern: Schema.String.pipe(optional),
+    placeholder: Schema.String.pipe(optional),
+    default: Schema.String.pipe(optional),
+    options: Schema.Array(Option).pipe(optional),
+    custom: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Form.StringField" });
+export const NumberField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("number"),
+    minimum: Schema.Number.pipe(optional),
+    maximum: Schema.Number.pipe(optional),
+    default: Schema.Number.pipe(optional),
+}).annotate({ identifier: "Form.NumberField" });
+export const IntegerField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("integer"),
+    minimum: Schema.Number.pipe(optional),
+    maximum: Schema.Number.pipe(optional),
+    default: Schema.Number.pipe(optional),
+}).annotate({ identifier: "Form.IntegerField" });
+export const BooleanField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("boolean"),
+    default: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Form.BooleanField" });
+export const MultiselectField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("multiselect"),
+    options: Schema.Array(Option),
+    minItems: NonNegativeInt.pipe(optional),
+    maxItems: NonNegativeInt.pipe(optional),
+    custom: Schema.Boolean.pipe(optional),
+    default: Schema.Array(Schema.String).pipe(optional),
+}).annotate({ identifier: "Form.MultiselectField" });
+export const ExternalField = Schema.Struct({
+    key: Schema.String,
+    type: Schema.Literal("external"),
+    url: Schema.String,
+    title: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+}).annotate({ identifier: "Form.ExternalField" });
+export const Field = Schema.Union([
+    StringField,
+    NumberField,
+    IntegerField,
+    BooleanField,
+    MultiselectField,
+    ExternalField,
+]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Form.Field" }));
+export const Fields = Schema.NonEmptyArray(Field).annotate({ identifier: "Form.Fields" });
+const InfoBase = {
+    id: ID,
+    // This should be typed as SessionID. It is a plain string only because MCP elicitation
+    // temporarily needs the `"global"` sentinel owner, which is not a real session. Once
+    // elicitations can be attributed to real sessions, revert this to SessionID. Do not rely
+    // on non-session owners anywhere else.
+    sessionID: Schema.String,
+    title: Schema.String,
+    metadata: Metadata.pipe(optional),
+};
+export const Info = Schema.Struct({
+    ...InfoBase,
+    fields: Fields,
+}).annotate({ identifier: "Form.Info" });
+export const Value = Schema.Union([Schema.String, Schema.Number, Schema.Boolean, Schema.Array(Schema.String)]).annotate({
+    identifier: "Form.Value",
+});
+export const Answer = Schema.Record(Schema.String, Value).annotate({ identifier: "Form.Answer" });
+export const State = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("pending") }),
+    Schema.Struct({ status: Schema.Literal("answered"), answer: Answer }),
+    Schema.Struct({ status: Schema.Literal("cancelled") }),
+])
+    .pipe(Schema.toTaggedUnion("status"))
+    .annotate({ identifier: "Form.State" });
+export const Reply = Schema.Struct({
+    answer: Answer,
+}).annotate({ identifier: "Form.Reply" });
+const Created = ephemeral({ type: "form.created", schema: { form: Info } });
+const Replied = ephemeral({ type: "form.replied", schema: { id: ID, sessionID: Schema.String, answer: Answer } });
+const Cancelled = ephemeral({ type: "form.cancelled", schema: { id: ID, sessionID: Schema.String } });
+export const Event = { Created, Replied, Cancelled, Definitions: inventory(Created, Replied, Cancelled) };

package/dist/ide-event.d.ts

@@ -0,0 +1,76 @@
+export * as IdeEvent from "./ide-event.js";
+import { Schema } from "effect";
+export declare const Installed: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"ide.installed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly ide: Schema.String;
+    }>;
+}> & {
+    type: "ide.installed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly ide: Schema.String;
+    }>;
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"ide.installed">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly ide: Schema.String;
+    }>;
+}> & {
+    type: "ide.installed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly ide: Schema.String;
+    }>;
+}];

package/dist/ide-event.js

@@ -0,0 +1,10 @@
+export * as IdeEvent from "./ide-event.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+export const Installed = Event.ephemeral({
+    type: "ide.installed",
+    schema: {
+        ide: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(Installed);

package/dist/identifier.d.ts

@@ -0,0 +1,3 @@
+export declare function ascending(): string;
+export declare function descending(): string;
+export declare function create(descending: boolean, timestamp?: number): string;

package/dist/identifier.js

@@ -0,0 +1,24 @@
+const length = 26;
+const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+let lastTimestamp = 0;
+let counter = 0;
+export function ascending() {
+    return create(false);
+}
+export function descending() {
+    return create(true);
+}
+export function create(descending, timestamp = Date.now()) {
+    if (timestamp !== lastTimestamp) {
+        lastTimestamp = timestamp;
+        counter = 0;
+    }
+    counter++;
+    const current = BigInt(timestamp) * 0x1000n + BigInt(counter);
+    const value = descending ? ~current : current;
+    const time = Array.from({ length: 6 }, (_, index) => Number((value >> BigInt(40 - 8 * index)) & 0xffn)
+        .toString(16)
+        .padStart(2, "0")).join("");
+    const bytes = crypto.getRandomValues(new Uint8Array(length - 12));
+    return time + Array.from(bytes, (byte) => chars[byte % 62]).join("");
+}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+export { Agent } from "./agent.js";
+export { Command } from "./command.js";
+export { Config } from "./config.js";
+export { Connection } from "./connection.js";
+export { Credential } from "./credential.js";
+export { Event } from "./event.js";
+export { FileSystem } from "./filesystem.js";
+export { Form } from "./form.js";
+export { Integration } from "./integration.js";
+export { LLM } from "./llm.js";
+export { AI } from "./ai.js";
+export { Location } from "./location.js";
+export { Mcp } from "./mcp.js";
+export { Model } from "./model.js";
+export { Money } from "./money.js";
+export { Permission } from "./permission.js";
+export { PermissionSaved } from "./permission-saved.js";
+export { Project } from "./project.js";
+export { Worktree } from "./worktree.js";
+export { Provider } from "./provider.js";
+export { Reference } from "./reference.js";
+export { WebSearch } from "./websearch.js";
+export { Session } from "./session.js";
+export { Vcs } from "./vcs.js";
+export { SessionInbox } from "./session-inbox.js";
+export { SessionError } from "./session-error.js";
+export { SessionMessage } from "./session-message.js";
+export { SessionTransfer } from "./session-transfer.js";
+export { Snapshot } from "./snapshot.js";
+export { Shell } from "./shell.js";
+export { Skill } from "./skill.js";
+export { TokenUsage } from "./token-usage.js";
+export { Pty } from "./pty.js";
+export { PtyTicket } from "./pty-ticket.js";
+export { Question } from "./question.js";
+export { Workspace } from "./workspace.js";
+export { Prompt, PromptMention, FileSource, FileAttachment, AgentAttachment } from "./prompt.js";
+export { PromptInput } from "./prompt-input.js";
+export * from "./schema.js";

package/dist/index.js

@@ -0,0 +1,39 @@
+export { Agent } from "./agent.js";
+export { Command } from "./command.js";
+export { Config } from "./config.js";
+export { Connection } from "./connection.js";
+export { Credential } from "./credential.js";
+export { Event } from "./event.js";
+export { FileSystem } from "./filesystem.js";
+export { Form } from "./form.js";
+export { Integration } from "./integration.js";
+export { LLM } from "./llm.js";
+export { AI } from "./ai.js";
+export { Location } from "./location.js";
+export { Mcp } from "./mcp.js";
+export { Model } from "./model.js";
+export { Money } from "./money.js";
+export { Permission } from "./permission.js";
+export { PermissionSaved } from "./permission-saved.js";
+export { Project } from "./project.js";
+export { Worktree } from "./worktree.js";
+export { Provider } from "./provider.js";
+export { Reference } from "./reference.js";
+export { WebSearch } from "./websearch.js";
+export { Session } from "./session.js";
+export { Vcs } from "./vcs.js";
+export { SessionInbox } from "./session-inbox.js";
+export { SessionError } from "./session-error.js";
+export { SessionMessage } from "./session-message.js";
+export { SessionTransfer } from "./session-transfer.js";
+export { Snapshot } from "./snapshot.js";
+export { Shell } from "./shell.js";
+export { Skill } from "./skill.js";
+export { TokenUsage } from "./token-usage.js";
+export { Pty } from "./pty.js";
+export { PtyTicket } from "./pty-ticket.js";
+export { Question } from "./question.js";
+export { Workspace } from "./workspace.js";
+export { Prompt, PromptMention, FileSource, FileAttachment, AgentAttachment } from "./prompt.js";
+export { PromptInput } from "./prompt-input.js";
+export * from "./schema.js";

package/dist/installation-event.d.ts

@@ -0,0 +1,149 @@
+export * as InstallationEvent from "./installation-event.js";
+import { Schema } from "effect";
+export declare const Updated: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"installation.updated">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}> & {
+    type: "installation.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+};
+export declare const UpdateAvailable: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"installation.update-available">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}> & {
+    type: "installation.update-available";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"installation.updated">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}> & {
+    type: "installation.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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 type: Schema.Literal<"installation.update-available">;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}> & {
+    type: "installation.update-available";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly version: Schema.String;
+    }>;
+}];

package/dist/installation-event.js

@@ -0,0 +1,16 @@
+export * as InstallationEvent from "./installation-event.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+export const Updated = Event.ephemeral({
+    type: "installation.updated",
+    schema: {
+        version: Schema.String,
+    },
+});
+export const UpdateAvailable = Event.ephemeral({
+    type: "installation.update-available",
+    schema: {
+        version: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(Updated, UpdateAvailable);

package/dist/instruction-entry.d.ts

@@ -0,0 +1,23 @@
+export * as InstructionEntry from "./instruction-entry.js";
+import { Schema } from "effect";
+/**
+ * Slash-free client-facing key for one API-managed instruction entry. The server
+ * derives the namespaced Instructions key as `api/<key>`, keeping the
+ * `api/*` namespace enforced by construction.
+ */
+export declare const Key: Schema.String;
+export type Key = typeof Key.Type;
+export declare const Info: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const MaxValueBytes: number;
+declare const ValueTooLargeError_base: Schema.Class<ValueTooLargeError, Schema.TaggedStruct<"InstructionEntryValueTooLargeError", {
+    readonly actualBytes: Schema.Int;
+    readonly maxBytes: Schema.Int;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ValueTooLargeError extends ValueTooLargeError_base {
+}

package/dist/instruction-entry.js

@@ -0,0 +1,22 @@
+export * as InstructionEntry from "./instruction-entry.js";
+import { Schema } from "effect";
+/**
+ * Slash-free client-facing key for one API-managed instruction entry. The server
+ * derives the namespaced Instructions key as `api/<key>`, keeping the
+ * `api/*` namespace enforced by construction.
+ */
+export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*$/)).annotate({
+    identifier: "InstructionEntry.Key",
+    description: "Instruction entry key (lowercase alphanumerics plus . _ -)",
+});
+export const Info = Schema.Struct({
+    key: Key,
+    value: Schema.Json.annotate({ description: "JSON value attached to the session's instructions" }),
+}).annotate({ identifier: "InstructionEntry.Info" });
+export const MaxValueBytes = 8 * 1024;
+export class ValueTooLargeError extends Schema.TaggedErrorClass()("InstructionEntryValueTooLargeError", {
+    actualBytes: Schema.Int,
+    maxBytes: Schema.Int,
+    message: Schema.String,
+}, { httpApiStatus: 413 }) {
+}

package/dist/instruction.d.ts

@@ -0,0 +1,13 @@
+export * as Instruction from "./instruction.js";
+import { Schema } from "effect";
+export declare const Key: Schema.brand<Schema.String, "Instruction.Key">;
+export type Key = typeof Key.Type;
+export declare const Hash: Schema.brand<Schema.String, "Instruction.Hash">;
+export type Hash = typeof Hash.Type;
+export declare const Values: Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>;
+export type Values = Readonly<Record<string, Hash>>;
+export declare const Removed: Schema.Literal<"removed">;
+export type Removed = typeof Removed.Type;
+export declare const removed: "removed";
+export declare const Delta: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.brand<Schema.String, "Instruction.Hash">, Schema.Literal<"removed">]>>;
+export type Delta = typeof Delta.Type;

package/dist/instruction.js

@@ -0,0 +1,8 @@
+export * as Instruction from "./instruction.js";
+import { Schema } from "effect";
+export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._/-]*$/)).pipe(Schema.brand("Instruction.Key"));
+export const Hash = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)).pipe(Schema.brand("Instruction.Hash"));
+export const Values = Schema.Record(Key, Hash);
+export const Removed = Schema.Literal("removed");
+export const removed = Removed.make("removed");
+export const Delta = Schema.Record(Schema.String, Schema.Union([Hash, Removed]));

package/dist/integration-id.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+export declare const IntegrationID: Schema.brand<Schema.String, "Integration.ID">;
+export type IntegrationID = typeof IntegrationID.Type;
+export declare const IntegrationMethodID: Schema.brand<Schema.String, "Integration.MethodID">;
+export type IntegrationMethodID = typeof IntegrationMethodID.Type;

package/dist/integration-id.js

@@ -0,0 +1,3 @@
+import { Schema } from "effect";
+export const IntegrationID = Schema.String.pipe(Schema.brand("Integration.ID"));
+export const IntegrationMethodID = Schema.String.pipe(Schema.brand("Integration.MethodID"));