@nyte-ai/schema 0.0.0-stage → 0.0.18

package/dist/chunks/browser-sgwxbek9.js

@@ -0,0 +1,37 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+
+// src/json.ts
+import { Type } from "typebox";
+import { Guard } from "typebox/guard";
+var JSON_DEFINITION = Type.Union([
+  Type.Null(),
+  Type.Boolean(),
+  Type.Number(),
+  Type.String(),
+  Type.Array(Type.Ref("Json")),
+  Type.Record(Type.String(), Type.Ref("Json"))
+]);
+var JsonType2 = Type.Unsafe(Type.Ref("Json"));
+var JsonObjectType2 = Type.Record(Type.String(), JsonType2);
+function cyclicWithJson2(definitions, ref) {
+  return Type.Cyclic({ Json: JSON_DEFINITION, ...definitions }, ref);
+}
+function withJson2(schema) {
+  return cyclicWithJson2({ Root: schema }, "Root");
+}
+var JsonValueSchema2 = standard2(withJson2(JsonType2));
+var JsonObjectSchema2 = standard2(withJson2(JsonObjectType2));
+function isJson2(value) {
+  if (Guard.IsArray(value))
+    return value.every(isJson2);
+  if (Guard.IsObject(value))
+    return Object.values(value).every(isJson2);
+  return Guard.IsNull(value) || Guard.IsString(value) || Guard.IsBoolean(value) || Guard.IsNumber(value);
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { JsonType2, JsonObjectType2, cyclicWithJson2, withJson2, JsonValueSchema2, JsonObjectSchema2, isJson2, isJsonObject2 };

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-vapnjwp3.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-8t9anqfc.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-vkh2tpmf.js

@@ -0,0 +1,283 @@
+import {
+  JsonType2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  ModelRefType2,
+  LoginMethodType2,
+  ModelAccountType2,
+  ProviderUsageType2,
+  ModelCatalogViewSchema2
+} from "./browser-8t9anqfc.js";
+import {
+  ConfigurationPatchType2,
+  ConfigurationType2
+} from "./browser-vapnjwp3.js";
+import {
+  UserContentType2
+} from "./browser-hq5q56sf.js";
+import {
+  AuthorityType2,
+  PrincipalViewWireType2,
+  PluginCheckReportSchema2,
+  PluginReplacementReportSchema2
+} from "./browser-6e1madxa.js";
+import {
+  WorkspaceTargetType2,
+  WorkspaceInfoType2,
+  AddOutcomeSchema2,
+  ForgetOutcomeSchema2,
+  WorkspaceInspectionSchema2
+} from "./browser-bg1esaw0.js";
+import {
+  SessionInfoType2
+} from "./browser-7gjnxy9m.js";
+import {
+  HostViewWireSchema2,
+  SettingOutcomeSchema2
+} from "./browser-e5xgzd28.js";
+import {
+  PromptOverrideType2
+} from "./browser-j629a6wa.js";
+import {
+  pagedSchema2,
+  ParentFilterType2
+} from "./browser-0byq2fja.js";
+import {
+  wireSchema2,
+  wireObject2,
+  SESSION2,
+  NOTHING2,
+  BYTES2
+} from "./browser-r87w64mz.js";
+
+// src/wire/operations/host.ts
+import { Type } from "typebox";
+var PARTICIPANT = { authority: "participant", scope: "host" };
+var OWNER = { authority: "owner", scope: "host" };
+var MAINTENANCE = { authority: "maintenance", scope: "host" };
+var PROVIDER = { provider: Type.String() };
+var PLUGIN_FILE = Type.Object({ path: Type.String() });
+var NO_INPUT = wireObject2({});
+var ON_PROVIDER = wireObject2(PROVIDER);
+var HOST_OPERATIONS2 = {
+  "connection.watch": {
+    ...PARTICIPANT,
+    kind: "watch",
+    input: NO_INPUT,
+    output: HostViewWireSchema2
+  },
+  "connection.blob": {
+    ...PARTICIPANT,
+    kind: "stream",
+    input: wireObject2({ id: idSchema2() }),
+    output: BYTES2
+  },
+  "models.list": { ...PARTICIPANT, kind: "query", input: NO_INPUT, output: ModelCatalogViewSchema2 },
+  "models.accounts": {
+    ...OWNER,
+    kind: "query",
+    input: wireObject2({ provider: Type.Optional(Type.String()) }),
+    output: wireSchema2(Type.Array(ModelAccountType2))
+  },
+  "models.selectAccount": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ ...PROVIDER, account: Type.String() }),
+    output: NOTHING2
+  },
+  "models.usage": {
+    ...OWNER,
+    kind: "query",
+    input: NO_INPUT,
+    output: wireSchema2(Type.Array(ProviderUsageType2))
+  },
+  "models.refresh": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ provider: Type.Optional(Type.String()) }),
+    output: NOTHING2
+  },
+  "models.setDefault": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ ref: ModelRefType2 }),
+    output: wireSchema2(Type.Union([
+      Type.Object({ kind: Type.Literal("set") }),
+      Type.Object({ kind: Type.Literal("unknown-model") })
+    ]))
+  },
+  "models.verify": {
+    ...OWNER,
+    kind: "command",
+    input: ON_PROVIDER,
+    output: wireSchema2(Type.Union([
+      Type.Object({ kind: Type.Literal("verified") }),
+      Type.Object({ kind: Type.Literal("unverified") }),
+      Type.Object({ kind: Type.Literal("failed"), reason: Type.String() })
+    ]))
+  },
+  "models.login": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({
+      ...PROVIDER,
+      method: LoginMethodType2,
+      label: Type.Optional(Type.String()),
+      browser: Type.Optional(Type.Union([Type.Literal("host"), Type.Literal("elsewhere")]))
+    }),
+    output: NOTHING2
+  },
+  "models.logout": { ...OWNER, kind: "command", input: ON_PROVIDER, output: NOTHING2 },
+  "login.steps": {
+    ...OWNER,
+    kind: "stream",
+    input: ON_PROVIDER,
+    output: wireSchema2(Type.Union([
+      Type.Object({
+        kind: Type.Literal("open"),
+        url: Type.String(),
+        code: Type.Optional(Type.String())
+      }),
+      Type.Object({
+        kind: Type.Literal("paste"),
+        message: Type.String(),
+        secret: Type.Boolean()
+      }),
+      Type.Object({
+        kind: Type.Literal("choose"),
+        message: Type.String(),
+        options: Type.Array(Type.Object({ id: Type.String(), label: Type.String() }))
+      }),
+      Type.Object({ kind: Type.Literal("waiting") }),
+      Type.Object({ kind: Type.Literal("done") }),
+      Type.Object({ kind: Type.Literal("failed"), reason: Type.String() })
+    ]))
+  },
+  "login.answer": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ ...PROVIDER, code: Type.String() }),
+    output: NOTHING2
+  },
+  "settings.apply": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ id: Type.String(), value: JsonType2 }),
+    output: SettingOutcomeSchema2
+  },
+  "workspaces.list": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: NO_INPUT,
+    output: wireSchema2(Type.Array(WorkspaceInfoType2))
+  },
+  "workspaces.inspect": {
+    ...OWNER,
+    kind: "query",
+    input: wireObject2({ target: WorkspaceTargetType2 }),
+    output: WorkspaceInspectionSchema2
+  },
+  "workspaces.add": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({
+      target: WorkspaceTargetType2,
+      options: Type.Optional(Type.Object({
+        projectResources: Type.Optional(Type.Boolean()),
+        expect: Type.Optional(Type.Object({ identity: idSchema2() }))
+      }))
+    }),
+    output: AddOutcomeSchema2
+  },
+  "workspaces.forget": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ id: idSchema2() }),
+    output: ForgetOutcomeSchema2
+  },
+  "sessions.watch": {
+    ...PARTICIPANT,
+    kind: "watch",
+    input: wireObject2({
+      parents: Type.Optional(ParentFilterType2),
+      limit: Type.Optional(Type.Number())
+    }),
+    output: wireSchema2(Type.Array(SessionInfoType2))
+  },
+  "sessions.start": {
+    ...PARTICIPANT,
+    kind: "receipt",
+    recovery: "replay",
+    input: wireObject2({
+      id: idSchema2(),
+      name: Type.Optional(Type.String()),
+      workspace: Type.Optional(idSchema2()),
+      parent: Type.Optional(idSchema2()),
+      configuration: Type.Optional(Type.Union([ConfigurationType2, ConfigurationPatchType2])),
+      prompt: Type.Optional(PromptOverrideType2),
+      isolation: Type.Optional(Type.Literal("worktree")),
+      content: UserContentType2
+    }),
+    output: wireObject2({
+      session: idSchema2(),
+      receipt: idSchema2(),
+      message: idSchema2()
+    })
+  },
+  "sessions.list": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: wireObject2({
+      parents: Type.Optional(ParentFilterType2),
+      cursor: Type.Optional(idSchema2()),
+      limit: Type.Optional(Type.Number())
+    }),
+    output: pagedSchema2(SessionInfoType2)
+  }
+};
+var MAINTENANCE_OPERATIONS2 = {
+  "plugins.replace": {
+    ...MAINTENANCE,
+    kind: "command",
+    input: wireObject2({
+      plugins: Type.Array(PLUGIN_FILE),
+      scope: Type.Optional(Type.Object(SESSION2))
+    }),
+    output: PluginReplacementReportSchema2
+  },
+  "plugins.check": {
+    ...MAINTENANCE,
+    kind: "query",
+    input: wireObject2({ plugins: Type.Array(PLUGIN_FILE) }),
+    output: PluginCheckReportSchema2
+  },
+  "principals.list": {
+    ...MAINTENANCE,
+    kind: "query",
+    input: NO_INPUT,
+    output: wireSchema2(Type.Array(PrincipalViewWireType2))
+  },
+  "principals.pair": {
+    ...MAINTENANCE,
+    kind: "command",
+    input: wireObject2({
+      authority: Type.Array(AuthorityType2),
+      label: Type.Optional(Type.String())
+    }),
+    output: wireObject2({
+      code: Type.String(),
+      expiresAt: Type.Number()
+    })
+  },
+  "principals.revoke": {
+    ...MAINTENANCE,
+    kind: "command",
+    input: wireObject2({ id: idSchema2() }),
+    output: NOTHING2
+  }
+};
+
+export { HOST_OPERATIONS2, MAINTENANCE_OPERATIONS2 };

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-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 };