@nyte-ai/schema 0.0.0-stage → 0.0.19

package/dist/chunks/browser-v70eq512.js

@@ -0,0 +1,215 @@
+import {
+  typed2,
+  object2
+} from "./browser-qkxe0fwp.js";
+
+// src/model/model.ts
+import { Type } from "typebox";
+var MODEL_THINKING_LEVELS2 = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var MODEL_MODES2 = ["fast"];
+var nullableString = Type.Union([Type.String(), Type.Null()]);
+var ModelCostRatesSchema = object2({
+  input: Type.Number(),
+  output: Type.Number(),
+  cacheRead: Type.Number(),
+  cacheWrite: Type.Number()
+});
+var ModelCostTierSchema = object2({
+  ...ModelCostRatesSchema.properties,
+  inputTokensAbove: Type.Number()
+});
+var ModelCostSchema = object2({
+  ...ModelCostRatesSchema.properties,
+  tiers: Type.Optional(Type.Array(ModelCostTierSchema))
+});
+var ThinkingLevelMapSchema = object2({
+  off: Type.Optional(nullableString),
+  minimal: Type.Optional(nullableString),
+  low: Type.Optional(nullableString),
+  medium: Type.Optional(nullableString),
+  high: Type.Optional(nullableString),
+  xhigh: Type.Optional(nullableString),
+  max: Type.Optional(nullableString)
+});
+var ModelPromptCacheSchema = object2({
+  short: Type.Optional(Type.Number()),
+  long: Type.Optional(Type.Number())
+});
+var ChatTemplateKwargValueSchema = Type.Union([
+  Type.String(),
+  Type.Number(),
+  Type.Boolean(),
+  Type.Null(),
+  object2({
+    $var: Type.Union([
+      Type.Literal("thinking.enabled"),
+      Type.Literal("thinking.effort"),
+      Type.Literal("thinking.budget")
+    ]),
+    omitWhenOff: Type.Optional(Type.Boolean())
+  })
+]);
+var OpenRouterRoutingSchema = object2({
+  allow_fallbacks: Type.Optional(Type.Boolean()),
+  require_parameters: Type.Optional(Type.Boolean()),
+  data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
+  zdr: Type.Optional(Type.Boolean()),
+  enforce_distillable_text: Type.Optional(Type.Boolean()),
+  order: Type.Optional(Type.Array(Type.String())),
+  only: Type.Optional(Type.Array(Type.String())),
+  ignore: Type.Optional(Type.Array(Type.String())),
+  quantizations: Type.Optional(Type.Array(Type.String())),
+  sort: Type.Optional(Type.Union([
+    Type.String(),
+    object2({ by: Type.Optional(Type.String()), partition: Type.Optional(nullableString) })
+  ])),
+  max_price: Type.Optional(object2({
+    prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    request: Type.Optional(Type.Union([Type.Number(), Type.String()]))
+  })),
+  preferred_min_throughput: Type.Optional(Type.Union([
+    Type.Number(),
+    object2({
+      p50: Type.Optional(Type.Number()),
+      p75: Type.Optional(Type.Number()),
+      p90: Type.Optional(Type.Number()),
+      p99: Type.Optional(Type.Number())
+    })
+  ])),
+  preferred_max_latency: Type.Optional(Type.Union([
+    Type.Number(),
+    object2({
+      p50: Type.Optional(Type.Number()),
+      p75: Type.Optional(Type.Number()),
+      p90: Type.Optional(Type.Number()),
+      p99: Type.Optional(Type.Number())
+    })
+  ]))
+});
+var VercelGatewayRoutingSchema = object2({
+  only: Type.Optional(Type.Array(Type.String())),
+  order: Type.Optional(Type.Array(Type.String()))
+});
+var OpenAICompletionsCompatSchema = object2({
+  supportsStore: Type.Optional(Type.Boolean()),
+  supportsDeveloperRole: Type.Optional(Type.Boolean()),
+  supportsReasoningEffort: Type.Optional(Type.Boolean()),
+  supportsUsageInStreaming: Type.Optional(Type.Boolean()),
+  supportsFinishReason: Type.Optional(Type.Boolean()),
+  maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+  requiresToolResultName: Type.Optional(Type.Boolean()),
+  requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
+  requiresThinkingAsText: Type.Optional(Type.Boolean()),
+  requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
+  thinkingFormat: Type.Optional(Type.Union([
+    Type.Literal("openai"),
+    Type.Literal("openrouter"),
+    Type.Literal("deepseek"),
+    Type.Literal("together"),
+    Type.Literal("baseten"),
+    Type.Literal("zai"),
+    Type.Literal("qwen"),
+    Type.Literal("chat-template"),
+    Type.Literal("qwen-chat-template"),
+    Type.Literal("string-thinking"),
+    Type.Literal("ant-ling")
+  ])),
+  chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargValueSchema)),
+  chatTemplateArgs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargValueSchema)),
+  openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
+  vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
+  zaiToolStream: Type.Optional(Type.Boolean()),
+  thinkingTokenBudgetField: Type.Optional(Type.Union([
+    Type.Literal("thinking_token_budget"),
+    Type.Literal("thinking_budget"),
+    Type.Literal("thinking_budget_tokens")
+  ])),
+  supportsThinkingTokenBudget: Type.Optional(Type.Boolean()),
+  supportsOpenAIGrammarTools: Type.Optional(Type.Boolean()),
+  supportsMidConvoSystemMessages: Type.Optional(Type.Boolean()),
+  supportsMidConvoToolAdditions: Type.Optional(Type.Boolean()),
+  supportsStrictMode: Type.Optional(Type.Boolean()),
+  cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
+  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+  deferredToolsMode: Type.Optional(Type.Literal("kimi")),
+  sessionAffinityFormat: Type.Optional(Type.Union([
+    Type.Literal("openai"),
+    Type.Literal("openai-nosession"),
+    Type.Literal("openrouter")
+  ])),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean())
+});
+var OpenAIResponsesCompatSchema = object2({
+  supportsDeveloperRole: Type.Optional(Type.Boolean()),
+  supportsMidConvoSystemMessages: Type.Optional(Type.Boolean()),
+  sessionAffinityFormat: Type.Optional(Type.Union([
+    Type.Literal("openai"),
+    Type.Literal("openai-nosession"),
+    Type.Literal("openrouter")
+  ])),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+  supportsStrictMode: Type.Optional(Type.Boolean()),
+  supportsOpenAIGrammarTools: Type.Optional(Type.Boolean()),
+  supportsAdditionalTools: Type.Optional(Type.Boolean()),
+  supportsToolSearch: Type.Optional(Type.Boolean()),
+  supportsExplicitPromptCacheMode: Type.Optional(Type.Boolean())
+});
+var AnthropicAllowedFallbackModelSchema = object2({
+  provider: Type.String(),
+  model: Type.String(),
+  cost: ModelCostSchema
+});
+var AnthropicMessagesCompatSchema = object2({
+  supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+  supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
+  supportsTemperature: Type.Optional(Type.Boolean()),
+  forceAdaptiveThinking: Type.Optional(Type.Boolean()),
+  allowEmptySignature: Type.Optional(Type.Boolean()),
+  supportsStrictTools: Type.Optional(Type.Boolean()),
+  supportsMidConvoSystemMessages: Type.Optional(Type.Boolean()),
+  supportsMidConvoToolChanges: Type.Optional(Type.Boolean()),
+  allowedFallbackModels: Type.Optional(Type.Array(AnthropicAllowedFallbackModelSchema)),
+  supportsToolReferences: Type.Optional(Type.Boolean())
+});
+var BedrockCompatSchema = object2({
+  supportsStrictMode: Type.Optional(Type.Boolean())
+});
+var ModelSchema2 = typed2()(object2({
+  id: Type.String(),
+  name: Type.String(),
+  api: Type.String(),
+  provider: Type.String(),
+  baseUrl: Type.String(),
+  reasoning: Type.Boolean(),
+  modes: Type.Optional(Type.Array(Type.Enum(MODEL_MODES2))),
+  variant: Type.Optional(object2({ mode: Type.Enum(MODEL_MODES2), base: Type.String() })),
+  thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+  promptCache: Type.Optional(ModelPromptCacheSchema),
+  input: Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")])),
+  cost: ModelCostSchema,
+  contextWindow: Type.Number(),
+  maxTokens: Type.Number(),
+  samplingParams: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  compat: Type.Optional(Type.Union([
+    OpenAICompletionsCompatSchema,
+    OpenAIResponsesCompatSchema,
+    AnthropicMessagesCompatSchema,
+    BedrockCompatSchema
+  ]))
+}));
+
+export { MODEL_THINKING_LEVELS2, MODEL_MODES2, ModelSchema2 };

package/dist/chunks/browser-vzc3r2r3.js

@@ -0,0 +1,64 @@
+// src/schema.ts
+import { IsCyclic } from "typebox";
+import { Compile } from "typebox/compile";
+import { HasCodec, ParseError } from "typebox/value";
+function definitions(schema) {
+  if (!IsCyclic(schema))
+    return {};
+  return Object.fromEntries(Object.entries(schema.$defs).flatMap(([name, definition]) => {
+    const plain = Object.fromEntries(Object.entries(definition).filter(([key]) => key !== "$id"));
+    return [
+      [name, plain],
+      [`urn:typebox:root:${name}`, plain]
+    ];
+  }));
+}
+function compile2(schema) {
+  return Compile(definitions(schema), schema);
+}
+function issues(errors) {
+  return {
+    issues: errors.map((error) => ({
+      message: error.message,
+      path: error.instancePath.split("/").filter(Boolean)
+    }))
+  };
+}
+function standard2(schema) {
+  let validator;
+  let codec = false;
+  const json = Object.fromEntries(Object.entries(schema));
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "typebox",
+      validate: (value) => {
+        if (!validator) {
+          validator = compile2(schema);
+          codec = HasCodec(validator.Context(), schema);
+        }
+        if (codec) {
+          return validator.Check(value) ? { value: validator.Decode(value) } : issues(validator.Errors(value));
+        }
+        try {
+          return { value: validator.Decode(value) };
+        } catch (error) {
+          if (error instanceof ParseError)
+            return issues(error.cause.errors);
+          throw error;
+        }
+      },
+      jsonSchema: {
+        input: () => json,
+        output() {
+          if (HasCodec(definitions(schema), schema))
+            throw new TypeError("A TypeBox codec does not declare its decoded output JSON Schema.");
+          return json;
+        }
+      },
+      types: undefined
+    }
+  };
+}
+
+export { compile2, standard2 };

package/dist/chunks/browser-xensz05x.js

@@ -0,0 +1,172 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  JsonType2,
+  JsonObjectType2,
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  UserContentType2,
+  PositionType2
+} from "./browser-hq5q56sf.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ModelRefType2
+} from "./browser-0sbkxgkx.js";
+import {
+  ExecutionType2
+} from "./browser-8ancsy4m.js";
+import {
+  ActivationType2
+} from "./browser-bg1esaw0.js";
+
+// src/sessions.ts
+import { Type } from "typebox";
+var HeadInfoType2 = Type.Object({
+  name: idSchema2(),
+  tip: PositionType2,
+  stack: nullable2(Type.Object({ parent: idSchema2(), base: PositionType2, stale: Type.Boolean() })),
+  execution: ExecutionType2,
+  unread: Type.Boolean()
+});
+var SessionInfoType2 = Type.Object({
+  id: idSchema2(),
+  name: nullable2(Type.String()),
+  parent: nullable2(idSchema2()),
+  call: nullable2(idSchema2()),
+  workspace: idSchema2(),
+  pinned: Type.Boolean(),
+  archived: Type.Boolean(),
+  activation: ActivationType2,
+  heads: Type.Array(HeadInfoType2),
+  createdAt: Type.Number(),
+  lastActivityAt: Type.Number()
+});
+var CLIENT_COMMAND_NAMES2 = [
+  "accounts",
+  "cd",
+  "compact",
+  "continue",
+  "edit",
+  "help",
+  "login",
+  "logout",
+  "mcp",
+  "new",
+  "plugins",
+  "pr",
+  "quit",
+  "reload",
+  "resume",
+  "sessions",
+  "settings",
+  "skills",
+  "tasks",
+  "tree",
+  "trust",
+  "update",
+  "usage"
+];
+var COMMAND_NAME2 = /^[a-z0-9][a-z0-9-]*$/u;
+var CommandInfoType2 = Type.Object({
+  name: Type.String(),
+  owner: Type.String(),
+  side: Type.Enum(["core", "client"]),
+  title: Type.String(),
+  description: Type.String(),
+  takesText: Type.Boolean(),
+  completes: Type.Boolean(),
+  category: Type.Optional(Type.String()),
+  keywords: Type.Optional(Type.Array(Type.String()))
+});
+var CommandCompletionType2 = Type.Object({
+  value: Type.String(),
+  label: Type.String(),
+  description: Type.Optional(Type.String())
+});
+var SettingInfoType2 = Type.Object({
+  id: Type.String(),
+  owner: Type.String(),
+  scope: Type.Enum(["host", "session"]),
+  label: Type.String(),
+  schema: JsonObjectType2,
+  choices: nullable2(Type.Array(Type.Object({ value: JsonType2, label: Type.String(), badge: Type.Optional(Type.String()) }))),
+  value: JsonType2,
+  from: Type.Enum(["default", "host", "session"])
+});
+var SkillInfoType2 = Type.Object({
+  name: Type.String(),
+  owner: Type.String(),
+  description: Type.String(),
+  location: Type.String()
+});
+var AgentInfoType2 = Type.Object({
+  id: Type.String(),
+  owner: Type.String(),
+  description: nullable2(Type.String()),
+  model: nullable2(ModelRefType2),
+  mode: Type.Enum(["primary", "subagent", "all"])
+});
+var ToolInfoType2 = Type.Object({
+  name: Type.String(),
+  owner: Type.String(),
+  namespace: nullable2(Type.String()),
+  description: Type.String(),
+  parameters: JsonObjectType2,
+  output: nullable2(JsonObjectType2),
+  exposure: Type.Enum(["model", "deferred", "code", "hidden"])
+});
+var SessionCatalogViewType2 = Type.Object({
+  commands: Type.Array(CommandInfoType2),
+  settings: Type.Array(SettingInfoType2),
+  skills: Type.Array(SkillInfoType2),
+  agents: Type.Array(AgentInfoType2),
+  tools: Type.Array(ToolInfoType2)
+});
+var WorkspaceCatalogViewType2 = Type.Object({
+  commands: Type.Array(CommandInfoType2),
+  skills: Type.Array(SkillInfoType2)
+});
+var CommandOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("ran"), output: nullable2(Type.String()) }),
+  Type.Object({ kind: Type.Literal("sent"), receipt: idSchema2() }),
+  Type.Object({ kind: Type.Literal("unknown") }),
+  Type.Object({ kind: Type.Literal("failed"), message: Type.String() })
+]);
+var WorkspaceCommandOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("ran"), output: nullable2(Type.String()) }),
+  Type.Object({ kind: Type.Literal("prompt"), content: UserContentType2 }),
+  Type.Object({ kind: Type.Literal("unknown") }),
+  Type.Object({ kind: Type.Literal("failed"), message: Type.String() })
+]);
+var UpdateOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("updated") }),
+  Type.Object({ kind: Type.Literal("busy"), runs: Type.Array(idSchema2()) }),
+  Type.Object({ kind: Type.Literal("unknown-workspace") })
+]);
+var RemoveSessionOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("removed") }),
+  Type.Object({ kind: Type.Literal("busy"), runs: Type.Array(idSchema2()) }),
+  Type.Object({ kind: Type.Literal("has-children"), children: Type.Array(idSchema2()) })
+]);
+var HeadInfoSchema2 = standard2(withJson2(HeadInfoType2));
+var SessionInfoSchema2 = standard2(withJson2(SessionInfoType2));
+var CommandInfoSchema2 = standard2(withJson2(CommandInfoType2));
+var SettingInfoSchema2 = standard2(withJson2(SettingInfoType2));
+var SkillInfoSchema2 = standard2(SkillInfoType2);
+var AgentInfoSchema2 = standard2(AgentInfoType2);
+var ToolInfoSchema2 = standard2(withJson2(ToolInfoType2));
+var SessionCatalogViewSchema2 = standard2(withJson2(SessionCatalogViewType2));
+var CommandOutcomeSchema2 = standard2(CommandOutcomeType2);
+var CommandCompletionsSchema2 = standard2(Type.Array(CommandCompletionType2));
+var WorkspaceCommandOutcomeSchema2 = standard2(WorkspaceCommandOutcomeType2);
+var UpdateOutcomeSchema2 = standard2(UpdateOutcomeType2);
+var RemoveSessionOutcomeSchema2 = standard2(RemoveSessionOutcomeType2);
+
+export { HeadInfoType2, SessionInfoType2, CLIENT_COMMAND_NAMES2, COMMAND_NAME2, CommandInfoType2, CommandCompletionType2, SettingInfoType2, SkillInfoType2, AgentInfoType2, ToolInfoType2, SessionCatalogViewType2, WorkspaceCatalogViewType2, CommandOutcomeType2, WorkspaceCommandOutcomeType2, UpdateOutcomeType2, RemoveSessionOutcomeType2, HeadInfoSchema2, SessionInfoSchema2, CommandInfoSchema2, SettingInfoSchema2, SkillInfoSchema2, AgentInfoSchema2, ToolInfoSchema2, SessionCatalogViewSchema2, CommandOutcomeSchema2, CommandCompletionsSchema2, WorkspaceCommandOutcomeSchema2, UpdateOutcomeSchema2, RemoveSessionOutcomeSchema2 };

package/dist/chunks/browser-ynj8v9ad.js

@@ -0,0 +1,35 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  JsonType2,
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ModelRefType2,
+  ThinkingType2
+} from "./browser-0sbkxgkx.js";
+
+// src/configuration.ts
+import { Type } from "typebox";
+var ConfigurationPatchType2 = Type.Object({
+  model: Type.Optional(ModelRefType2),
+  thinking: Type.Optional(nullable2(ThinkingType2)),
+  agent: Type.Optional(nullable2(Type.String())),
+  settings: Type.Optional(Type.Record(Type.String(), JsonType2))
+});
+var ConfigurationType2 = Type.Object({
+  kind: Type.Literal("exact"),
+  model: ModelRefType2,
+  thinking: ThinkingType2,
+  agent: nullable2(Type.String()),
+  settings: Type.Record(Type.String(), JsonType2),
+  settingsVersion: Type.String()
+});
+var ConfigurationPatchSchema2 = standard2(withJson2(ConfigurationPatchType2));
+var ConfigurationSchema2 = standard2(withJson2(ConfigurationType2));
+
+export { ConfigurationPatchType2, ConfigurationType2, ConfigurationPatchSchema2, ConfigurationSchema2 };

package/dist/chunks/browser-ypez6s7v.js

@@ -0,0 +1,52 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+
+// src/ids.ts
+import { Type } from "typebox";
+function branded(_value) {
+  return true;
+}
+function asId2(value) {
+  if (!branded(value))
+    throw new Error("unreachable");
+  return value;
+}
+function asSeq2(value) {
+  if (!branded(value))
+    throw new Error("unreachable");
+  return value;
+}
+function idSchema2() {
+  return Type.Unsafe(Type.String());
+}
+var SeqType2 = Type.Unsafe(Type.Integer({ minimum: 0 }));
+var SessionIdSchema2 = standard2(idSchema2());
+var HeadNameSchema2 = standard2(idSchema2());
+var RunIdSchema2 = standard2(idSchema2());
+var CallIdSchema2 = standard2(idSchema2());
+var MessageIdSchema2 = standard2(idSchema2());
+var TurnIdSchema2 = standard2(idSchema2());
+var CommitIdSchema2 = standard2(idSchema2());
+var ObjectIdSchema2 = standard2(idSchema2());
+var BlobIdSchema2 = standard2(idSchema2());
+var PartIdSchema2 = standard2(idSchema2());
+var ReceiptIdSchema2 = standard2(idSchema2());
+var JobIdSchema2 = standard2(idSchema2());
+var JobKeySchema2 = standard2(idSchema2());
+var WorkspaceIdSchema2 = standard2(idSchema2());
+var PageIdSchema2 = standard2(idSchema2());
+var HostIdSchema2 = standard2(idSchema2());
+var PrincipalIdSchema2 = standard2(idSchema2());
+var SnapshotIdSchema2 = standard2(idSchema2());
+var GitCommitIdSchema2 = standard2(idSchema2());
+var GitRevisionSchema2 = standard2(idSchema2());
+var FileVersionSchema2 = standard2(idSchema2());
+var DocumentRevisionSchema2 = standard2(idSchema2());
+var RevisionSchema2 = standard2(idSchema2());
+var CatalogGenerationSchema2 = standard2(idSchema2());
+var CursorSchema2 = standard2(idSchema2());
+var SeqSchema2 = standard2(SeqType2);
+var EnvironmentIdentitySchema2 = standard2(idSchema2());
+
+export { asId2, asSeq2, idSchema2, SeqType2, SessionIdSchema2, HeadNameSchema2, RunIdSchema2, CallIdSchema2, MessageIdSchema2, TurnIdSchema2, CommitIdSchema2, ObjectIdSchema2, BlobIdSchema2, PartIdSchema2, ReceiptIdSchema2, JobIdSchema2, JobKeySchema2, WorkspaceIdSchema2, PageIdSchema2, HostIdSchema2, PrincipalIdSchema2, SnapshotIdSchema2, GitCommitIdSchema2, GitRevisionSchema2, FileVersionSchema2, DocumentRevisionSchema2, RevisionSchema2, CatalogGenerationSchema2, CursorSchema2, SeqSchema2, EnvironmentIdentitySchema2 };

package/dist/src/browser.d.ts

@@ -0,0 +1,64 @@
+import { Type } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const PageInfoType: Type.TObject<{
+    id: Type.TUnsafe<import("./ids.ts").Id<"page">>;
+    url: Type.TString;
+    title: Type.TString;
+    holders: Type.TNumber;
+}>;
+export type PageInfo = Decoded<typeof PageInfoType>;
+export declare const PageViewType: Type.TObject<{
+    id: Type.TUnsafe<import("./ids.ts").Id<"page">>;
+    url: Type.TString;
+    title: Type.TString;
+    loading: Type.TBoolean;
+    revision: Type.TUnsafe<import("./ids.ts").Id<"document-revision">>;
+    canGoBack: Type.TBoolean;
+    canGoForward: Type.TBoolean;
+}>;
+export type PageView = Decoded<typeof PageViewType>;
+export declare const PageSnapshotType: Type.TObject<{
+    revision: Type.TUnsafe<import("./ids.ts").Id<"document-revision">>;
+    nodes: Type.TArray<Type.TObject<{
+        ref: Type.TString;
+        role: Type.TString;
+        name: Type.TString;
+        editable: Type.TBoolean;
+        depth: Type.TNumber;
+    }>>;
+}>;
+export type PageSnapshot = Decoded<typeof PageSnapshotType>;
+export declare const ConsoleEntryType: Type.TObject<{
+    level: Type.TEnum<["log", "info", "warn", "error"]>;
+    text: Type.TString;
+    at: Type.TNumber;
+}>;
+export type ConsoleEntry = Decoded<typeof ConsoleEntryType>;
+export declare const PageOutcomeType: Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"applied">;
+    snapshot: Type.TObject<{
+        revision: Type.TUnsafe<import("./ids.ts").Id<"document-revision">>;
+        nodes: Type.TArray<Type.TObject<{
+            ref: Type.TString;
+            role: Type.TString;
+            name: Type.TString;
+            editable: Type.TBoolean;
+            depth: Type.TNumber;
+        }>>;
+    }>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"stale">;
+    revision: Type.TUnsafe<import("./ids.ts").Id<"document-revision">>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"refused">;
+    reason: Type.TEnum<["unknown-ref", "occluded", "not-visible", "policy"]>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"closed">;
+    reason: Type.TEnum<["released", "reclaimed", "crashed"]>;
+}>]>;
+export type PageOutcome = Decoded<typeof PageOutcomeType>;
+export declare const PageInfoSchema: Schema<PageInfo>;
+export declare const PageViewSchema: Schema<PageView>;
+export declare const PageSnapshotSchema: Schema<PageSnapshot>;
+export declare const ConsoleEntrySchema: Schema<ConsoleEntry>;
+export declare const PageOutcomeSchema: Schema<PageOutcome>;

package/dist/src/browser.js

@@ -0,0 +1,26 @@
+import {
+  PageInfoType2,
+  PageViewType2,
+  PageSnapshotType2,
+  ConsoleEntryType2,
+  PageOutcomeType2,
+  PageInfoSchema2,
+  PageViewSchema2,
+  PageSnapshotSchema2,
+  ConsoleEntrySchema2,
+  PageOutcomeSchema2
+} from "../chunks/browser-mzfc0v5j.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  ConsoleEntrySchema2 as ConsoleEntrySchema,
+  ConsoleEntryType2 as ConsoleEntryType,
+  PageInfoSchema2 as PageInfoSchema,
+  PageInfoType2 as PageInfoType,
+  PageOutcomeSchema2 as PageOutcomeSchema,
+  PageOutcomeType2 as PageOutcomeType,
+  PageSnapshotSchema2 as PageSnapshotSchema,
+  PageSnapshotType2 as PageSnapshotType,
+  PageViewSchema2 as PageViewSchema,
+  PageViewType2 as PageViewType
+};

package/dist/src/configuration.d.ts

@@ -0,0 +1,26 @@
+import { Type } from "typebox";
+import type { Decoded, Schema } from "./schema.ts";
+export declare const ConfigurationPatchType: Type.TObject<{
+    model: Type.TOptional<Type.TObject<{
+        provider: Type.TString;
+        id: Type.TString;
+    }>>;
+    thinking: Type.TOptional<Type.TUnion<[Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>, Type.TNull]>>;
+    agent: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
+    settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>>;
+}>;
+export type ConfigurationPatch = Decoded<typeof ConfigurationPatchType>;
+export declare const ConfigurationType: Type.TObject<{
+    kind: Type.TLiteral<"exact">;
+    model: Type.TObject<{
+        provider: Type.TString;
+        id: Type.TString;
+    }>;
+    thinking: Type.TEnum<["off", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+    agent: Type.TUnion<[Type.TString, Type.TNull]>;
+    settings: Type.TRecord<"^.*$", Type.TUnsafe<import("./json.ts").Json>>;
+    settingsVersion: Type.TString;
+}>;
+export type Configuration = Decoded<typeof ConfigurationType>;
+export declare const ConfigurationPatchSchema: Schema<ConfigurationPatch>;
+export declare const ConfigurationSchema: Schema<Configuration>;

package/dist/src/configuration.js

@@ -0,0 +1,17 @@
+import {
+  ConfigurationPatchType2,
+  ConfigurationType2,
+  ConfigurationPatchSchema2,
+  ConfigurationSchema2
+} from "../chunks/browser-ynj8v9ad.js";
+import"../chunks/browser-0sbkxgkx.js";
+import"../chunks/browser-sgwxbek9.js";
+import"../chunks/browser-4et7qtz3.js";
+import"../chunks/browser-ypez6s7v.js";
+import"../chunks/browser-vzc3r2r3.js";
+export {
+  ConfigurationPatchSchema2 as ConfigurationPatchSchema,
+  ConfigurationPatchType2 as ConfigurationPatchType,
+  ConfigurationSchema2 as ConfigurationSchema,
+  ConfigurationType2 as ConfigurationType
+};