@nyte-ai/schema 0.0.0-stage → 0.0.19

package/dist/chunks/browser-pdv675va.js

@@ -0,0 +1,135 @@
+import {
+  idSchema2,
+  BlobIdSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  FileEntryViewType2,
+  FileEventType2,
+  SearchInputType2,
+  ScanFrameSchema2,
+  SearchFrameSchema2,
+  FormatOutcomeSchema2,
+  WriteOutcomeSchema2,
+  FileDocumentSchema2
+} from "./browser-ebr6k189.js";
+import {
+  wireSchema2,
+  wireObject2,
+  WORKSPACE2,
+  PATH2,
+  BYTES2,
+  ON_WORKSPACE2,
+  ON_PATH2,
+  RECEIPT_ID2
+} from "./browser-r87w64mz.js";
+
+// src/wire/operations/files.ts
+import { Type } from "typebox";
+var FILES = { authority: "participant", scope: "workspace", capability: "files" };
+var QUERY_INPUT = wireObject2({
+  ...WORKSPACE2,
+  query: Type.String(),
+  limit: Type.Optional(Type.Number())
+});
+var FILE_OPERATIONS2 = {
+  "files.read": { ...FILES, kind: "query", input: ON_PATH2, output: FileDocumentSchema2 },
+  "files.bytes": { ...FILES, kind: "stream", input: ON_PATH2, output: BYTES2 },
+  "files.stat": {
+    ...FILES,
+    kind: "query",
+    input: ON_PATH2,
+    output: wireSchema2(nullable2(Type.Object({
+      kind: Type.Enum(["file", "directory", "symlink"]),
+      size: Type.Number(),
+      version: idSchema2(),
+      target: Type.Optional(Type.String())
+    })))
+  },
+  "files.write": {
+    ...FILES,
+    kind: "command",
+    input: wireObject2({
+      ...PATH2,
+      options: Type.Optional(Type.Object({
+        expect: Type.Optional(Type.Union([Type.Literal("absent"), idSchema2()])),
+        parents: Type.Optional(Type.Boolean())
+      }))
+    }),
+    output: WriteOutcomeSchema2
+  },
+  "files.remove": {
+    ...FILES,
+    kind: "command",
+    input: wireObject2({
+      ...PATH2,
+      options: Type.Optional(Type.Object({ expect: Type.Optional(idSchema2()) }))
+    }),
+    output: WriteOutcomeSchema2
+  },
+  "files.batch": {
+    ...FILES,
+    kind: "receipt",
+    recovery: "replay",
+    input: wireObject2({
+      ...WORKSPACE2,
+      id: Type.Optional(idSchema2()),
+      entries: Type.Array(Type.Union([
+        Type.Object({
+          kind: Type.Literal("put"),
+          path: Type.String(),
+          contents: Type.Union([Type.String(), Type.Object({ blob: idSchema2() })]),
+          expect: Type.Optional(Type.Union([Type.Literal("absent"), idSchema2()]))
+        }),
+        Type.Object({
+          kind: Type.Literal("remove"),
+          path: Type.String(),
+          expect: Type.Optional(idSchema2())
+        })
+      ]))
+    }),
+    output: RECEIPT_ID2
+  },
+  "files.format": {
+    ...FILES,
+    kind: "query",
+    input: wireObject2({ ...PATH2, contents: Type.String() }),
+    output: FormatOutcomeSchema2
+  },
+  "files.scan": {
+    ...FILES,
+    kind: "stream",
+    input: wireObject2({
+      ...WORKSPACE2,
+      directory: Type.Optional(Type.String()),
+      ignored: Type.Optional(Type.Enum(["exclude", "include"]))
+    }),
+    output: ScanFrameSchema2
+  },
+  "files.find": {
+    ...FILES,
+    kind: "query",
+    input: QUERY_INPUT,
+    output: wireSchema2(Type.Array(FileEntryViewType2))
+  },
+  "files.search": {
+    ...FILES,
+    kind: "stream",
+    input: wireObject2({ ...WORKSPACE2, ...SearchInputType2.properties }),
+    output: SearchFrameSchema2
+  },
+  "files.watch": {
+    ...FILES,
+    kind: "watch",
+    input: wireObject2({
+      ...WORKSPACE2,
+      paths: Type.Optional(Type.Array(Type.String()))
+    }),
+    output: wireSchema2(Type.Array(FileEventType2))
+  },
+  "files.upload": { ...FILES, kind: "command", input: ON_WORKSPACE2, output: BlobIdSchema2 }
+};
+
+export { FILE_OPERATIONS2 };

package/dist/chunks/browser-pvfshqyk.js

@@ -0,0 +1,36 @@
+import {
+  BROWSER_OPERATIONS2
+} from "./browser-fd3accdr.js";
+import {
+  FILE_OPERATIONS2
+} from "./browser-pdv675va.js";
+import {
+  GIT_OPERATIONS2
+} from "./browser-0xr6c36r.js";
+import {
+  GITHUB_OPERATIONS2
+} from "./browser-0g0z3617.js";
+import {
+  HOST_OPERATIONS2,
+  MAINTENANCE_OPERATIONS2
+} from "./browser-sgst60b0.js";
+import {
+  SESSION_OPERATIONS2
+} from "./browser-jgxe05s4.js";
+import {
+  WORKSPACE_OPERATIONS2
+} from "./browser-h5k4hqfq.js";
+
+// src/wire/operations/index.ts
+var OPERATIONS2 = {
+  ...HOST_OPERATIONS2,
+  ...SESSION_OPERATIONS2,
+  ...WORKSPACE_OPERATIONS2,
+  ...FILE_OPERATIONS2,
+  ...GIT_OPERATIONS2,
+  ...GITHUB_OPERATIONS2,
+  ...BROWSER_OPERATIONS2,
+  ...MAINTENANCE_OPERATIONS2
+};
+
+export { OPERATIONS2 };

package/dist/chunks/browser-qkxe0fwp.js

@@ -0,0 +1,6 @@
+// src/model/typed.ts
+import { Type, Unsafe } from "typebox";
+var typed2 = () => (schema) => Unsafe(schema);
+var object2 = (properties) => Type.Object(properties, { additionalProperties: false });
+
+export { typed2, object2 };

package/dist/chunks/browser-qncc807c.js

@@ -0,0 +1,66 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  JsonType2,
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ModelRefType2,
+  ThinkingType2
+} from "./browser-0sbkxgkx.js";
+import {
+  ConfigurationPatchType2,
+  ConfigurationType2
+} from "./browser-ynj8v9ad.js";
+import {
+  DeliveryType2,
+  UserContentType2,
+  MessageSourceType2
+} from "./browser-hq5q56sf.js";
+import {
+  ToolClassType2
+} from "./browser-h86zs54a.js";
+
+// src/hooks.ts
+import { Type } from "typebox";
+var SubmissionType2 = Type.Object({
+  content: UserContentType2,
+  source: MessageSourceType2,
+  delivery: DeliveryType2,
+  configuration: nullable2(Type.Union([ConfigurationType2, ConfigurationPatchType2])),
+  replace: nullable2(idSchema2())
+});
+var ModelRequestType2 = Type.Object({
+  model: ModelRefType2,
+  thinking: ThinkingType2,
+  step: Type.Enum(["assistant", "compaction", "summary"]),
+  attempt: Type.Number(),
+  options: Type.Object({
+    sampling: Type.Record(Type.String(), JsonType2),
+    headers: Type.Record(Type.String(), Type.String())
+  })
+});
+var ToolCallType2 = Type.Object({
+  call: idSchema2(),
+  name: Type.String(),
+  args: JsonType2,
+  class: ToolClassType2
+});
+var SubmitDraftType2 = Type.Object({
+  content: UserContentType2,
+  delivery: DeliveryType2,
+  session: nullable2(idSchema2())
+});
+var SubmissionSchema2 = standard2(withJson2(SubmissionType2));
+var ModelRequestSchema2 = standard2(withJson2(ModelRequestType2));
+var ToolCallSchema2 = standard2(withJson2(ToolCallType2));
+var SubmitDraftSchema2 = standard2(SubmitDraftType2);
+
+export { SubmissionType2, ModelRequestType2, ToolCallType2, SubmitDraftType2, SubmissionSchema2, ModelRequestSchema2, ToolCallSchema2, SubmitDraftSchema2 };

package/dist/chunks/browser-r87w64mz.js

@@ -0,0 +1,32 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  base64Bytes2
+} from "./browser-m0wzr0g8.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  withJson2
+} from "./browser-sgwxbek9.js";
+
+// src/wire/operations/fields.ts
+import { Type } from "typebox";
+function wireSchema2(type) {
+  return standard2(withJson2(type));
+}
+function wireObject2(properties) {
+  return wireSchema2(Type.Object(properties));
+}
+var SESSION2 = { session: idSchema2() };
+var WORKSPACE2 = { workspace: idSchema2() };
+var PATH2 = { ...WORKSPACE2, path: Type.String() };
+var NOTHING2 = wireSchema2(Type.Null());
+var BYTES2 = wireSchema2(base64Bytes2);
+var ON_SESSION2 = wireObject2(SESSION2);
+var ON_WORKSPACE2 = wireObject2(WORKSPACE2);
+var ON_PATH2 = wireObject2(PATH2);
+var RECEIPT_ID2 = wireObject2({ receipt: idSchema2() });
+
+export { wireSchema2, wireObject2, SESSION2, WORKSPACE2, PATH2, NOTHING2, BYTES2, ON_SESSION2, ON_WORKSPACE2, ON_PATH2, RECEIPT_ID2 };

package/dist/chunks/browser-s2xe7c21.js

@@ -0,0 +1,82 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ValidationIssueType2
+} from "./browser-1sfp0bcx.js";
+import {
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  UserContentType2
+} from "./browser-hq5q56sf.js";
+import {
+  SendOptionsType2
+} from "./browser-0chm3654.js";
+import {
+  AuthorityType2
+} from "./browser-6e1madxa.js";
+import {
+  SettingInfoType2
+} from "./browser-xensz05x.js";
+
+// src/connection.ts
+import { Type } from "typebox";
+var HostViewWireType2 = Type.Object({
+  id: idSchema2(),
+  link: Type.Union([
+    Type.Object({ kind: Type.Literal("connected") }),
+    Type.Object({
+      kind: Type.Literal("reconnecting"),
+      since: Type.Number(),
+      attempts: Type.Number()
+    }),
+    Type.Object({
+      kind: Type.Literal("closed"),
+      reason: Type.Enum(["client", "revoked", "host-gone"])
+    })
+  ]),
+  name: Type.String(),
+  platform: Type.String(),
+  version: Type.String(),
+  catalog: idSchema2(),
+  plugins: Type.Array(Type.Object({
+    id: Type.String(),
+    source: Type.Enum(["builtin", "user", "project", "inline"]),
+    path: nullable2(Type.String()),
+    issues: Type.Array(ValidationIssueType2)
+  })),
+  settings: Type.Array(SettingInfoType2),
+  defaultWorkspace: nullable2(idSchema2()),
+  authority: Type.Array(AuthorityType2),
+  principal: idSchema2()
+});
+var CredentialSourceWireType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("token"), token: Type.String() }),
+  Type.Object({ kind: Type.Literal("pairing"), code: Type.String() })
+]);
+var JournalEntryType2 = Type.Object({
+  id: idSchema2(),
+  session: idSchema2(),
+  head: idSchema2(),
+  content: UserContentType2,
+  options: SendOptionsType2,
+  at: Type.Number()
+});
+var SettingOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("applied") }),
+  Type.Object({ kind: Type.Literal("invalid"), issues: Type.Array(ValidationIssueType2) }),
+  Type.Object({ kind: Type.Literal("unknown") })
+]);
+var HostViewWireSchema2 = standard2(withJson2(HostViewWireType2));
+var CredentialSourceWireSchema2 = standard2(CredentialSourceWireType2);
+var JournalEntrySchema2 = standard2(withJson2(JournalEntryType2));
+var SettingOutcomeSchema2 = standard2(SettingOutcomeType2);
+
+export { HostViewWireType2, CredentialSourceWireType2, JournalEntryType2, SettingOutcomeType2, HostViewWireSchema2, CredentialSourceWireSchema2, JournalEntrySchema2, SettingOutcomeSchema2 };

package/dist/chunks/browser-sgst60b0.js

@@ -0,0 +1,293 @@
+import {
+  JsonType2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  ModelRefType2,
+  LoginMethodType2,
+  ModelAccountType2,
+  ProviderUsageType2,
+  ModelListingType2,
+  ModelCatalogViewSchema2
+} from "./browser-0sbkxgkx.js";
+import {
+  ConfigurationPatchType2,
+  ConfigurationType2
+} from "./browser-ynj8v9ad.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-xensz05x.js";
+import {
+  HostViewWireSchema2,
+  SettingOutcomeSchema2
+} from "./browser-s2xe7c21.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.setListing": {
+    ...OWNER,
+    kind: "command",
+    input: wireObject2({ refs: Type.Array(ModelRefType2), listing: ModelListingType2 }),
+    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-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 };