@opencode/schema 2.0.3 → 2.0.5

package/dist/session-inbox.d.ts

@@ -474,7 +474,9 @@ export declare const User: Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export interface Synthetic extends Schema.Schema.Type<typeof Synthetic> {
 }
@@ -494,7 +496,9 @@ export declare const Synthetic: Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export interface Compaction extends Schema.Schema.Type<typeof Compaction> {
 }
@@ -510,7 +514,9 @@ export declare const Compaction: Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export interface Move extends Schema.Schema.Type<typeof Move> {
 }
@@ -541,7 +547,9 @@ export declare const Move: Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>;
 export declare const Info: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.tag<"user">;
@@ -685,7 +693,9 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"synthetic">;
     readonly payload: Schema.Struct<{
@@ -702,7 +712,9 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"compaction">;
     readonly payload: Schema.Struct<{}>;
@@ -715,7 +727,9 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>, Schema.Struct<{
     readonly type: Schema.tag<"move">;
     readonly payload: Schema.Struct<{
@@ -743,6 +757,8 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
 }>]>;
 export type Info = typeof Info.Type;

package/dist/session-inbox.js

@@ -34,7 +34,7 @@ export const Item = Schema.Union([UserItem, SyntheticItem, CompactionItem, MoveI
 const Enqueued = {
     id: SessionMessage.ID,
     sessionID: SessionID,
-    timeCreated: DateTimeUtcFromMillis,
+    time: Schema.Struct({ created: DateTimeUtcFromMillis }),
 };
 export const User = Schema.Struct({ ...Enqueued, ...UserItem.fields }).annotate({ identifier: "Session.Inbox.User" });
 export const Synthetic = Schema.Struct({ ...Enqueued, ...SyntheticItem.fields }).annotate({

package/dist/session-revert.d.ts

@@ -510,7 +510,7 @@ export declare const PersistedRevert: Schema.decodeTo<Schema.toType<Schema.Struc
                     readonly diff?: string | undefined;
                 };
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "current" | "legacy">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "legacy" | "current">]: never; }, OrElse extends (value: Exclude<{
             readonly source: "current";
             readonly revert: {
                 readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -605,7 +605,7 @@ export declare const PersistedRevert: Schema.decodeTo<Schema.toType<Schema.Struc
                     readonly diff?: string | undefined;
                 };
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "current" | "legacy">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "legacy" | "current">]: never; }, OrElse extends (value: Exclude<{
             readonly source: "current";
             readonly revert: {
                 readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/session.d.ts

@@ -28,16 +28,6 @@ export declare const ForkBoundary: Schema.Union<readonly [Schema.Struct<{
     };
 }>]>;
 export type ForkBoundary = SessionFork.Boundary;
-export declare const ForkRequestBoundary: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"before">;
-    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-        fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
-    };
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"through">;
-}>]>;
-export type ForkRequestBoundary = SessionFork.RequestBoundary;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
 export declare const Info: Schema.Struct<{

package/dist/session.js

@@ -18,7 +18,6 @@ export const Metadata = SessionMetadata;
 export const Event = SessionEvent;
 export { Revert };
 export const ForkBoundary = SessionFork.Boundary;
-export const ForkRequestBoundary = SessionFork.RequestBoundary;
 export const Info = Schema.Struct({
     id: ID,
     parentID: ID.pipe(optional),

package/dist/shell.d.ts

@@ -360,7 +360,7 @@ export declare const Event: {
 export declare const CreateInput: Schema.Struct<{
     readonly command: Schema.String;
     readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly timeout: Schema.Int;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     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 interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {

package/dist/shell.js

@@ -14,8 +14,10 @@ export const ID = IDSchema.pipe(statics((schema) => {
 }));
 export const Status = Schema.Literals(["running", "exited", "timeout", "killed"]);
 export const Time = Schema.Struct({
-    started: Schema.Finite,
-    completed: optional(Schema.Finite),
+    started: Schema.Finite.annotate({ description: "Start time in milliseconds since the Unix epoch" }),
+    completed: optional(Schema.Finite).annotate({
+        description: "Completion time in milliseconds since the Unix epoch",
+    }),
 });
 // Opaque caller-supplied tags echoed back on Info and events. The Shell service never interprets
 // these; callers (e.g. ShellTool stores the originating session ID) use them to filter or correlate.
@@ -41,7 +43,7 @@ export const Event = { Created, Exited, Deleted, Definitions: inventory(Created,
 export const CreateInput = Schema.Struct({
     command: Schema.String,
     cwd: optional(Schema.String),
-    timeout: NonNegativeInt,
+    timeout: optional(NonNegativeInt),
     metadata: optional(Metadata),
 });
 export const OutputInput = Schema.Struct({

package/dist/skill.d.ts

@@ -22,9 +22,8 @@ export declare const Info: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Skill.ID">;
     readonly name: Schema.brand<Schema.String, "Skill.Name">;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
     readonly content: Schema.String;
 }>;
 export declare const Event: {
@@ -103,9 +102,8 @@ export declare const EmbeddedSource: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Skill.ID">;
         readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
         readonly content: Schema.String;
     }>>;
 }>;
@@ -122,9 +120,8 @@ export declare const Source: Schema.Union<readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Skill.ID">;
         readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
         readonly content: Schema.String;
     }>>;
 }>]> & {

package/dist/skill.js

@@ -17,9 +17,8 @@ export const Info = Schema.Struct({
     id: ID,
     name: Name,
     description: Schema.String.pipe(optional),
-    slash: Schema.Boolean.pipe(optional),
     autoinvoke: Schema.Boolean.pipe(optional),
-    location: AbsolutePath,
+    path: AbsolutePath,
     content: Schema.String,
 }).annotate({ identifier: "Skill.Info" });
 const Updated = ephemeral({ type: "skill.updated", schema: {} });

package/dist/vcs.d.ts

@@ -7,6 +7,7 @@ export declare const Branch: Schema.Struct<{
 export interface Branch extends Schema.Schema.Type<typeof Branch> {
 }
 export declare const Info: Schema.Struct<{
+    readonly provider: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly branch: Schema.Struct<{
         readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/vcs.js

@@ -6,6 +6,7 @@ export const Branch = Schema.Struct({
     default: optional(Schema.String),
 }).annotate({ identifier: "Vcs.Branch" });
 export const Info = Schema.Struct({
+    provider: optional(Schema.String),
     branch: Branch,
 }).annotate({ identifier: "Vcs.Info" });
 export const BranchList = Schema.Array(Schema.String).annotate({ identifier: "Vcs.BranchList" });

package/dist/websearch.js

@@ -16,7 +16,9 @@ export const Result = Schema.Struct({
     title: Schema.String.pipe(optional),
     content: Schema.String.pipe(optional),
     time: Schema.Struct({
-        published: Schema.Finite.pipe(optional),
+        published: Schema.Finite.pipe(optional).annotate({
+            description: "Publication time in milliseconds since the Unix epoch",
+        }),
     }),
 }).annotate({ identifier: "WebSearch.Result" });
 export class Response extends Schema.Class("WebSearch.Response")({

package/dist/worktree.d.ts

@@ -3,7 +3,9 @@ import { Schema } from "effect";
 export declare const StrategyID: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
 export type StrategyID = typeof StrategyID.Type;
 export declare const CreateInput: Schema.Struct<{
-    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Trim, "Worktree.StrategyID">>>, Schema.optionalKey<Schema.brand<Schema.Trim, "Worktree.StrategyID">>, never, never>;
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
     readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
     readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
     readonly directory: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
@@ -12,6 +14,9 @@ export declare const CreateInput: Schema.Struct<{
 export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
 }
 export declare const RemoveInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly force: Schema.Boolean;
 }>;

package/dist/worktree.js

@@ -5,15 +5,16 @@ import { AbsolutePath, optional } from "./schema.js";
 import { Project } from "./project.js";
 export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("Worktree.StrategyID"));
 export const CreateInput = Schema.Struct({
-    strategy: optional(StrategyID),
+    projectID: Project.ID,
     from: optional(AbsolutePath),
     branch: optional(Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()))),
     directory: optional(AbsolutePath).annotate({
-        description: "Parent directory for the new worktree. Uses the location's configuration, then defaults to the server's data directory under worktree/<first six project ID characters>.",
+        description: "Parent directory for the new worktree. Uses the project's canonical configuration, then defaults to the server's data directory under worktree/<first six project ID characters>.",
     }),
     name: optional(Schema.String),
 }).annotate({ identifier: "Worktree.CreateInput" });
 export const RemoveInput = Schema.Struct({
+    projectID: Project.ID,
     directory: AbsolutePath,
     force: Schema.Boolean,
 }).annotate({ identifier: "Worktree.RemoveInput" });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "type": "module",
   "license": "MIT",
   "repository": {

package/dist/catalog.d.ts

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

package/dist/catalog.js

@@ -1,4 +0,0 @@
-export * as Catalog from "./catalog.js";
-import { ephemeral, inventory } from "./event.js";
-const Updated = ephemeral({ type: "catalog.updated", schema: {} });
-export const Event = { Updated, Definitions: inventory(Updated) };