@opencode-ai/schema 0.0.0-next-15090 → 0.0.0-next-15092

package/dist/event.d.ts

@@ -54,6 +54,7 @@ export type Payload<D extends Definition = Definition> = D extends DurableDefini
 };
 type Input<Type extends string, Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>> = {
     readonly type: Type;
+    readonly identifier?: string;
     readonly durable?: {
         readonly version: number;
         readonly aggregate: string;
@@ -72,7 +73,7 @@ export declare function durable<const Type extends string, const Fields extends
     readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
     }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/event.js

@@ -1,5 +1,5 @@
 export * as Event from "./event.js";
-import { Schema } from "effect";
+import { Schema, SchemaTransformation } from "effect";
 import { optional } from "./schema.js";
 import { ascending } from "./identifier.js";
 import { Location } from "./location.js";
@@ -16,16 +16,24 @@ export const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(S
 const DurableEnvelope = Schema.Struct({ aggregateID: Schema.String, seq: Seq, version: Version });
 export function durable(input) {
     const data = Schema.Struct(input.schema);
+    const durable = Schema.Struct({
+        aggregateID: DurableEnvelope.fields.aggregateID,
+        seq: DurableEnvelope.fields.seq,
+        version: Schema.Literal(input.durable.version).pipe(Schema.decodeTo(Schema.toType(Version), SchemaTransformation.transform({
+            decode: () => Version.make(input.durable.version),
+            encode: () => input.durable.version,
+        }))),
+    });
     return Schema.Struct({
         id: ID,
         created: DateTimeUtcFromMillis,
         metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
         type: Schema.Literal(input.type),
-        durable: DurableEnvelope,
+        durable,
         location: optional(Location.Ref),
         data,
     })
-        .annotate({ identifier: input.type })
+        .annotate({ identifier: input.identifier ?? input.type })
         .pipe(statics(() => ({
         type: input.type,
         durability: "durable",
@@ -43,7 +51,7 @@ export function ephemeral(input) {
         location: optional(Location.Ref),
         data,
     })
-        .annotate({ identifier: input.type })
+        .annotate({ identifier: input.identifier ?? input.type })
         .pipe(statics(() => ({
         type: input.type,
         durability: "ephemeral",

package/dist/file-diff.d.ts

@@ -1,11 +1,21 @@
 export * as FileDiff from "./file-diff.js";
 import { Schema } from "effect";
 export declare const Info: Schema.Struct<{
+    readonly file: Schema.String;
+    readonly patch: Schema.String;
+    readonly additions: Schema.Int;
+    readonly deletions: Schema.Int;
+    readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+/** V1 snapshot and persisted session diff shape. */
+export declare const LegacyInfo: Schema.Struct<{
     readonly file: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly patch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly additions: Schema.Finite;
     readonly deletions: Schema.Finite;
     readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["added", "deleted", "modified"]>>>, Schema.optionalKey<Schema.Literals<readonly ["added", "deleted", "modified"]>>, never, never>;
 }>;
-export interface Info extends Schema.Schema.Type<typeof Info> {
+export interface LegacyInfo extends Schema.Schema.Type<typeof LegacyInfo> {
 }

package/dist/file-diff.js

@@ -1,10 +1,18 @@
 export * as FileDiff from "./file-diff.js";
 import { Schema } from "effect";
-import { optional } from "./schema.js";
+import { NonNegativeInt, optional } from "./schema.js";
 export const Info = Schema.Struct({
-    file: optional(Schema.String),
-    patch: optional(Schema.String),
+    file: Schema.String,
+    patch: Schema.String,
+    additions: NonNegativeInt,
+    deletions: NonNegativeInt,
+    status: Schema.Literals(["added", "deleted", "modified"]),
+}).annotate({ identifier: "FileDiff.Info" });
+/** V1 snapshot and persisted session diff shape. */
+export const LegacyInfo = Schema.Struct({
+    file: Schema.String.pipe(optional),
+    patch: Schema.String.pipe(optional),
     additions: Schema.Finite,
     deletions: Schema.Finite,
-    status: optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "SnapshotFileDiff" });
+    status: Schema.Literals(["added", "deleted", "modified"]).pipe(optional),
+}).annotate({ identifier: "FileDiff.LegacyInfo" });

package/dist/index.d.ts

@@ -11,20 +11,22 @@ export { LLM } from "./llm.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 { ProjectCopy } from "./project-copy.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
-export { Revert } from "./revert.js";
 export { Session } from "./session.js";
 export { Vcs } from "./vcs.js";
 export { SessionInput } from "./session-input.js";
 export { SessionError } from "./session-error.js";
 export { SessionMessage } from "./session-message.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";

package/dist/index.js

@@ -11,20 +11,22 @@ export { LLM } from "./llm.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 { ProjectCopy } from "./project-copy.js";
 export { Provider } from "./provider.js";
 export { Reference } from "./reference.js";
-export { Revert } from "./revert.js";
 export { Session } from "./session.js";
 export { Vcs } from "./vcs.js";
 export { SessionInput } from "./session-input.js";
 export { SessionError } from "./session-error.js";
 export { SessionMessage } from "./session-message.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";

package/dist/model.d.ts

@@ -1,12 +1,12 @@
 export * as Model from "./model.js";
 import { Schema } from "effect";
 import { Provider } from "./provider.js";
-export declare const ID: Schema.brand<Schema.String, "ModelV2.ID">;
+export declare const ID: Schema.brand<Schema.String, "Model.ID">;
 export type ID = typeof ID.Type;
-export declare const VariantID: Schema.brand<Schema.String, "VariantID">;
+export declare const VariantID: Schema.brand<Schema.String, "Model.VariantID">;
 export type VariantID = typeof VariantID.Type;
 export declare const Ref: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
     readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
         opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
@@ -20,11 +20,11 @@ export declare const Ref: Schema.Struct<{
         mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
     };
-    readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+    readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
 }>;
 export interface Ref extends Schema.Schema.Type<typeof Ref> {
 }
-export declare const Family: Schema.brand<Schema.String, "Family">;
+export declare const Family: Schema.brand<Schema.String, "Model.Family">;
 export type Family = typeof Family.Type;
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
 }
@@ -37,17 +37,25 @@ export interface Cost extends Schema.Schema.Type<typeof Cost> {
 }
 export declare const Cost: Schema.Struct<{
     readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly type: Schema.Literal<"context">;
+        readonly type: Schema.tag<"context">;
         readonly size: Schema.Int;
     }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly type: Schema.Literal<"context">;
+        readonly type: Schema.tag<"context">;
         readonly size: Schema.Int;
     }>>, never, never>;
-    readonly input: Schema.Finite;
-    readonly output: Schema.Finite;
+    readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
     readonly cache: Schema.Struct<{
-        readonly read: Schema.Finite;
-        readonly write: Schema.Finite;
+        readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
     }>;
 }>;
 export interface Variant extends Schema.Schema.Type<typeof Variant> {
@@ -56,7 +64,7 @@ export declare const Variant: Schema.Struct<{
     readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
     readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
-    readonly id: Schema.brand<Schema.String, "VariantID">;
+    readonly id: Schema.brand<Schema.String, "Model.VariantID">;
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
@@ -70,24 +78,32 @@ export declare const Info: Schema.Struct<{
         readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
         readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
         readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
-        readonly id: Schema.brand<Schema.String, "VariantID">;
+        readonly id: Schema.brand<Schema.String, "Model.VariantID">;
     }>>;
     readonly time: Schema.Struct<{
         readonly released: Schema.Finite;
     }>;
     readonly cost: Schema.$Array<Schema.Struct<{
         readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly type: Schema.Literal<"context">;
+            readonly type: Schema.tag<"context">;
             readonly size: Schema.Int;
         }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly type: Schema.Literal<"context">;
+            readonly type: Schema.tag<"context">;
             readonly size: Schema.Int;
         }>>, never, never>;
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
+        readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
         readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
+            readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
         }>;
     }>>;
     readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
@@ -100,8 +116,8 @@ export declare const Info: Schema.Struct<{
     readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
     readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
-    readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
-    readonly modelID: Schema.brand<Schema.String, "ModelV2.ID">;
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
     readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
         opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
@@ -115,7 +131,7 @@ export declare const Info: Schema.Struct<{
         mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
     };
-    readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Family">>, never, never>;
+    readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
     readonly name: Schema.String;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }> & {
@@ -126,7 +142,7 @@ export declare const Info: Schema.Struct<{
             readonly output: readonly string[];
         };
         readonly variants: readonly {
-            readonly id: string & import("effect/Brand").Brand<"VariantID">;
+            readonly id: string & import("effect/Brand").Brand<"Model.VariantID">;
             readonly settings?: {
                 readonly [x: string]: Schema.Json;
             } | undefined;
@@ -141,11 +157,11 @@ export declare const Info: Schema.Struct<{
             readonly released: number;
         };
         readonly cost: readonly {
-            readonly input: number;
-            readonly output: number;
+            readonly input: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            readonly output: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
             readonly cache: {
-                readonly read: number;
-                readonly write: number;
+                readonly read: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                readonly write: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
             };
             readonly tier?: {
                 readonly type: "context";
@@ -159,8 +175,8 @@ export declare const Info: Schema.Struct<{
             readonly output: number;
             readonly input?: number | undefined;
         };
-        readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
-        readonly modelID: string & import("effect/Brand").Brand<"ModelV2.ID">;
+        readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+        readonly modelID: string & import("effect/Brand").Brand<"Model.ID">;
         readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         readonly name: string;
         readonly settings?: {
@@ -172,7 +188,7 @@ export declare const Info: Schema.Struct<{
         readonly body?: {
             readonly [x: string]: Schema.Json;
         } | undefined;
-        readonly family?: (string & import("effect/Brand").Brand<"Family">) | undefined;
+        readonly family?: (string & import("effect/Brand").Brand<"Model.Family">) | undefined;
         readonly package?: string | undefined;
     };
 };

package/dist/model.js

@@ -2,14 +2,15 @@ export * as Model from "./model.js";
 import { Schema } from "effect";
 import { optional, statics } from "./schema.js";
 import { Provider } from "./provider.js";
-export const ID = Schema.String.pipe(Schema.brand("ModelV2.ID"));
-export const VariantID = Schema.String.pipe(Schema.brand("VariantID"));
+import { Money } from "./money.js";
+export const ID = Schema.String.pipe(Schema.brand("Model.ID"));
+export const VariantID = Schema.String.pipe(Schema.brand("Model.VariantID"));
 export const Ref = Schema.Struct({
     id: ID,
     providerID: Provider.ID,
     variant: VariantID.pipe(optional),
 }).annotate({ identifier: "Model.Ref" });
-export const Family = Schema.String.pipe(Schema.brand("Family"));
+export const Family = Schema.String.pipe(Schema.brand("Model.Family"));
 export const Capabilities = Schema.Struct({
     tools: Schema.Boolean,
     input: Schema.Array(Schema.String),
@@ -17,14 +18,14 @@ export const Capabilities = Schema.Struct({
 }).annotate({ identifier: "Model.Capabilities" });
 export const Cost = Schema.Struct({
     tier: Schema.Struct({
-        type: Schema.Literal("context"),
+        type: Schema.tag("context"),
         size: Schema.Int,
     }).pipe(optional),
-    input: Schema.Finite,
-    output: Schema.Finite,
+    input: Money.USDPerMillionTokens,
+    output: Money.USDPerMillionTokens,
     cache: Schema.Struct({
-        read: Schema.Finite,
-        write: Schema.Finite,
+        read: Money.USDPerMillionTokens,
+        write: Money.USDPerMillionTokens,
     }),
 }).annotate({ identifier: "Model.Cost" });
 export const Variant = Schema.Struct({
@@ -53,7 +54,7 @@ export const Info = Schema.Struct({
         output: Schema.Int,
     }),
 })
-    .annotate({ identifier: "ModelV2.Info" })
+    .annotate({ identifier: "Model.Info" })
     .pipe(statics((schema) => ({
     empty: (providerID, id) => schema.make({
         id,

package/dist/money.d.ts

@@ -0,0 +1,10 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+export declare const USD: Schema.brand<Schema.Finite, "Money.USD"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USD">;
+};
+export type USD = typeof USD.Type;
+export declare const USDPerMillionTokens: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+};
+export type USDPerMillionTokens = typeof USDPerMillionTokens.Type;

package/dist/money.js

@@ -0,0 +1,5 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+import { statics } from "./schema.js";
+export const USD = Schema.Finite.pipe(Schema.brand("Money.USD"), Schema.annotate({ identifier: "Money.USD" }), statics((schema) => ({ zero: schema.make(0) })));
+export const USDPerMillionTokens = Schema.Finite.pipe(Schema.brand("Money.USDPerMillionTokens"), Schema.annotate({ identifier: "Money.USDPerMillionTokens" }), statics((schema) => ({ zero: schema.make(0) })));