@nyte-ai/schema 0.0.0-stage → 0.0.18

package/dist/chunks/browser-pdx38ng3.js

@@ -0,0 +1,301 @@
+import {
+  JsonType2,
+  JsonValueSchema2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ConfigurationPatchType2
+} from "./browser-vapnjwp3.js";
+import {
+  ValidationIssueType2
+} from "./browser-1sfp0bcx.js";
+import {
+  UserContentType2,
+  PositionType2
+} from "./browser-hq5q56sf.js";
+import {
+  MoveOutcomeType2,
+  MoveOptionsType2,
+  SendOptionsType2,
+  TreeViewSchema2,
+  CreateHeadOutcomeSchema2,
+  MergeOutcomeSchema2,
+  RemoveHeadOutcomeSchema2,
+  ConfigureOutcomeSchema2
+} from "./browser-mnejgne0.js";
+import {
+  RunEndType2,
+  stopOutcomeSchema2,
+  RunEndSchema2
+} from "./browser-s7907azt.js";
+import {
+  PlacementType2,
+  actOutcomeSchema2
+} from "./browser-ad9yebg7.js";
+import {
+  SessionInfoSchema2,
+  CommandOutcomeSchema2,
+  CommandCompletionsSchema2,
+  UpdateOutcomeSchema2,
+  RemoveSessionOutcomeSchema2
+} from "./browser-7gjnxy9m.js";
+import {
+  ViewOptionsType2,
+  UserStatusType2,
+  HistoryPageType2,
+  SessionViewSchema2,
+  ViewFrameSchema2
+} from "./browser-bxz3z1v6.js";
+import {
+  wireSchema2,
+  wireObject2,
+  SESSION2,
+  NOTHING2,
+  ON_SESSION2,
+  RECEIPT_ID2
+} from "./browser-r87w64mz.js";
+
+// src/wire/operations/session.ts
+import { Type } from "typebox";
+var PARTICIPANT = { authority: "participant", scope: "session" };
+var [, , LANDED] = UserStatusType2.anyOf;
+var [, ...MOVE_FAILURES] = MoveOutcomeType2.anyOf;
+var HEAD = { ...SESSION2, head: idSchema2() };
+var PART = { ...SESSION2, part: idSchema2() };
+var NAMED_HEAD = { ...SESSION2, name: idSchema2() };
+var ON_RUN = wireObject2({ ...SESSION2, run: idSchema2() });
+var ON_RECEIPT = wireObject2({
+  session: nullable2(idSchema2()),
+  receipt: idSchema2()
+});
+var ON_PART = wireObject2(PART);
+var NAMED_HEAD_INPUT = wireObject2({
+  ...NAMED_HEAD,
+  options: Type.Optional(Type.Object({ expect: Type.Optional(idSchema2()) }))
+});
+var SESSION_OPERATIONS2 = {
+  "session.info": { ...PARTICIPANT, kind: "query", input: ON_SESSION2, output: SessionInfoSchema2 },
+  "session.update": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({
+      ...SESSION2,
+      patch: Type.Object({
+        name: Type.Optional(nullable2(Type.String())),
+        pinned: Type.Optional(Type.Boolean()),
+        archived: Type.Optional(Type.Boolean()),
+        workspace: Type.Optional(idSchema2())
+      })
+    }),
+    output: UpdateOutcomeSchema2
+  },
+  "session.remove": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: ON_SESSION2,
+    output: RemoveSessionOutcomeSchema2
+  },
+  "session.stop": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: ON_SESSION2,
+    output: wireObject2({
+      stopped: Type.Array(idSchema2()),
+      withdrawn: Type.Array(idSchema2())
+    })
+  },
+  "session.command": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({
+      ...SESSION2,
+      name: Type.String(),
+      text: Type.String()
+    }),
+    output: CommandOutcomeSchema2
+  },
+  "session.completeCommand": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: wireObject2({ ...SESSION2, name: Type.String(), prefix: Type.String() }),
+    output: CommandCompletionsSchema2
+  },
+  "head.send": {
+    ...PARTICIPANT,
+    kind: "receipt",
+    recovery: "replay",
+    input: wireObject2({
+      ...HEAD,
+      content: UserContentType2,
+      options: Type.Optional(SendOptionsType2)
+    }),
+    output: wireObject2({
+      receipt: idSchema2(),
+      message: idSchema2()
+    })
+  },
+  "head.configure": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({ ...HEAD, patch: ConfigurationPatchType2 }),
+    output: ConfigureOutcomeSchema2
+  },
+  "head.view": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: wireObject2({ ...HEAD, options: Type.Optional(ViewOptionsType2) }),
+    output: SessionViewSchema2
+  },
+  "head.watch": {
+    ...PARTICIPANT,
+    kind: "watch",
+    input: wireObject2({ ...HEAD, options: Type.Optional(ViewOptionsType2) }),
+    output: ViewFrameSchema2
+  },
+  "head.history": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: wireObject2({
+      ...HEAD,
+      before: idSchema2(),
+      limit: Type.Number()
+    }),
+    output: wireSchema2(HistoryPageType2)
+  },
+  "head.tree": { ...PARTICIPANT, kind: "query", input: wireObject2(HEAD), output: TreeViewSchema2 },
+  "head.move": {
+    ...PARTICIPANT,
+    kind: "receipt",
+    recovery: "replay",
+    input: wireObject2({
+      ...HEAD,
+      position: PositionType2,
+      options: Type.Optional(MoveOptionsType2),
+      id: Type.Optional(idSchema2())
+    }),
+    output: RECEIPT_ID2
+  },
+  "head.compact": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({
+      ...HEAD,
+      instructions: Type.Optional(Type.String())
+    }),
+    output: wireSchema2(Type.Union([
+      Type.Object({ kind: Type.Literal("started"), message: idSchema2() }),
+      Type.Object({ kind: Type.Literal("busy"), run: idSchema2() }),
+      Type.Object({ kind: Type.Literal("nothing-to-compact") })
+    ]))
+  },
+  "heads.create": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({
+      ...NAMED_HEAD,
+      input: Type.Optional(Type.Object({ from: Type.Optional(PositionType2) }))
+    }),
+    output: CreateHeadOutcomeSchema2
+  },
+  "heads.merge": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: NAMED_HEAD_INPUT,
+    output: MergeOutcomeSchema2
+  },
+  "heads.remove": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: NAMED_HEAD_INPUT,
+    output: RemoveHeadOutcomeSchema2
+  },
+  "run.stop": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: ON_RUN,
+    output: stopOutcomeSchema2(RunEndType2)
+  },
+  "run.settled": { ...PARTICIPANT, kind: "query", wait: true, input: ON_RUN, output: RunEndSchema2 },
+  "receipt.status": {
+    ...PARTICIPANT,
+    kind: "query",
+    input: ON_RECEIPT,
+    output: wireSchema2(Type.Union([
+      Type.Object({ kind: Type.Literal("pending") }),
+      Type.Object({ kind: Type.Literal("settled"), outcome: JsonType2 }),
+      Type.Object({ kind: Type.Literal("missing") })
+    ]))
+  },
+  "receipt.settled": {
+    ...PARTICIPANT,
+    kind: "query",
+    wait: true,
+    input: ON_RECEIPT,
+    output: JsonValueSchema2
+  },
+  "receipt.stop": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: ON_RECEIPT,
+    output: stopOutcomeSchema2(JsonType2)
+  },
+  "receipt.landed": {
+    ...PARTICIPANT,
+    kind: "query",
+    wait: true,
+    input: ON_RECEIPT,
+    output: wireSchema2(Type.Union([LANDED, Type.Object({ kind: Type.Literal("withdrawn") }), ...MOVE_FAILURES]))
+  },
+  "parts.create": {
+    ...PARTICIPANT,
+    kind: "command",
+    recovery: "replay",
+    input: wireObject2({
+      ...SESSION2,
+      kind: Type.String(),
+      input: Type.Object({
+        state: JsonType2,
+        placement: PlacementType2,
+        id: Type.Optional(idSchema2())
+      })
+    }),
+    output: wireObject2({ part: idSchema2() })
+  },
+  "part.update": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({
+      ...PART,
+      next: JsonType2,
+      options: Type.Optional(Type.Object({ version: Type.Optional(Type.Number()) }))
+    }),
+    output: wireSchema2(Type.Union([
+      Type.Object({ kind: Type.Literal("updated"), version: Type.Number() }),
+      Type.Object({ kind: Type.Literal("invalid"), issues: Type.Array(ValidationIssueType2) }),
+      Type.Object({ kind: Type.Literal("closed") }),
+      Type.Object({ kind: Type.Literal("missing") }),
+      Type.Object({ kind: Type.Literal("stale") })
+    ]))
+  },
+  "part.act": {
+    ...PARTICIPANT,
+    kind: "command",
+    input: wireObject2({ ...PART, action: Type.String(), input: JsonType2 }),
+    output: actOutcomeSchema2(JsonType2)
+  },
+  "part.answer": {
+    ...PARTICIPANT,
+    kind: "query",
+    wait: true,
+    input: ON_PART,
+    output: wireSchema2(nullable2(Type.Object({ action: Type.String(), input: JsonType2 })))
+  },
+  "part.close": { ...PARTICIPANT, kind: "command", input: ON_PART, output: NOTHING2 }
+};
+
+export { SESSION_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-r00v3vwv.js

@@ -0,0 +1,238 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  JsonType2,
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2,
+  SeqType2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  UsageType2,
+  ContextViewType2
+} from "./browser-8t9anqfc.js";
+import {
+  ConfigurationType2
+} from "./browser-vapnjwp3.js";
+import {
+  FailureType2
+} from "./browser-1sfp0bcx.js";
+import {
+  FileChangeType2
+} from "./browser-ebr6k189.js";
+import {
+  DeliveryType2,
+  UserContentType2,
+  MessageSourceType2,
+  ScheduleType2
+} from "./browser-hq5q56sf.js";
+import {
+  RunViewType2,
+  RunEndType2,
+  WaitTargetType2,
+  BackgroundItemType2
+} from "./browser-s7907azt.js";
+import {
+  ToolOutcomeType2,
+  ToolProgressType2
+} from "./browser-h86zs54a.js";
+import {
+  PlacementType2
+} from "./browser-ad9yebg7.js";
+import {
+  ActivationType2
+} from "./browser-bg1esaw0.js";
+import {
+  SessionInfoType2,
+  SessionCatalogViewType2
+} from "./browser-7gjnxy9m.js";
+
+// src/events.ts
+import { Type } from "typebox";
+var CHANGES = nullable2(Type.Object({ added: Type.Number(), removed: Type.Number(), paths: Type.Array(Type.String()) }));
+var REPLACED = nullable2(Type.Object({ previous: idSchema2(), stopped: nullable2(idSchema2()) }));
+var CommitBodyType2 = Type.Union([
+  Type.Object({
+    kind: Type.Literal("user"),
+    message: idSchema2(),
+    content: UserContentType2,
+    source: MessageSourceType2,
+    delivery: DeliveryType2,
+    siblings: Type.Array(idSchema2())
+  }),
+  Type.Object({ kind: Type.Literal("part"), part: idSchema2() }),
+  Type.Object({
+    kind: Type.Literal("compaction"),
+    part: idSchema2(),
+    replaces: Type.Array(idSchema2())
+  }),
+  Type.Object({
+    kind: Type.Literal("branchSummary"),
+    part: idSchema2(),
+    replaces: Type.Array(idSchema2())
+  })
+]);
+var INPUT = { kind: Type.Literal("input"), message: idSchema2() };
+var RUN = { kind: Type.Literal("run"), run: idSchema2() };
+var PART = { kind: Type.Literal("part"), part: idSchema2() };
+var CALL = { kind: Type.Literal("call"), call: idSchema2(), part: idSchema2() };
+var PATCH = { kind: Type.Literal("patch"), part: idSchema2() };
+function durableEvent(common) {
+  return Type.Union([
+    Type.Object({
+      ...common,
+      kind: Type.Literal("commit"),
+      id: idSchema2(),
+      parent: nullable2(idSchema2()),
+      run: nullable2(idSchema2()),
+      body: CommitBodyType2
+    }),
+    Type.Object({
+      ...common,
+      kind: Type.Literal("head"),
+      from: nullable2(idSchema2()),
+      to: nullable2(idSchema2()),
+      reason: Type.Enum(["moved", "merged", "created", "removed"])
+    }),
+    Type.Object({
+      ...common,
+      kind: Type.Literal("seen"),
+      principal: idSchema2(),
+      commit: nullable2(idSchema2())
+    }),
+    Type.Object({
+      ...common,
+      ...INPUT,
+      change: Type.Literal("admitted"),
+      content: UserContentType2,
+      source: MessageSourceType2,
+      delivery: DeliveryType2,
+      schedule: ScheduleType2,
+      covered: Type.Boolean(),
+      configuration: ConfigurationType2,
+      replaced: REPLACED
+    }),
+    Type.Object({
+      ...common,
+      ...INPUT,
+      change: Type.Literal("scheduled"),
+      schedule: ScheduleType2,
+      position: Type.Number()
+    }),
+    Type.Object({
+      ...common,
+      ...INPUT,
+      change: Type.Literal("landed"),
+      commit: idSchema2(),
+      run: nullable2(idSchema2())
+    }),
+    Type.Object({ ...common, ...INPUT, change: Type.Literal("withdrawn") }),
+    Type.Object({
+      ...common,
+      ...INPUT,
+      change: Type.Literal("superseded"),
+      by: idSchema2()
+    }),
+    Type.Object({ ...common, ...RUN, change: Type.Literal("started"), view: RunViewType2 }),
+    Type.Object({
+      ...common,
+      ...RUN,
+      change: Type.Literal("phase"),
+      phase: Type.Enum(["responding", "executing"])
+    }),
+    Type.Object({ ...common, ...RUN, change: Type.Literal("waiting"), on: WaitTargetType2 }),
+    Type.Object({
+      ...common,
+      ...RUN,
+      change: Type.Literal("retrying"),
+      attempt: Type.Number(),
+      until: Type.Number(),
+      reason: Type.String()
+    }),
+    Type.Object({ ...common, ...RUN, change: Type.Literal("stopping") }),
+    Type.Object({ ...common, ...RUN, change: Type.Literal("ended"), end: RunEndType2 }),
+    Type.Object({
+      ...common,
+      ...PART,
+      change: Type.Literal("created"),
+      partKind: Type.String(),
+      placement: PlacementType2,
+      state: JsonType2,
+      version: Type.Number(),
+      run: nullable2(idSchema2()),
+      owner: nullable2(Type.String())
+    }),
+    Type.Object({
+      ...common,
+      ...PART,
+      change: Type.Literal("updated"),
+      state: JsonType2,
+      version: Type.Number()
+    }),
+    Type.Object({ ...common, ...PART, change: Type.Literal("waiting"), call: idSchema2() }),
+    Type.Object({
+      ...common,
+      ...PART,
+      change: Type.Literal("settled"),
+      commit: idSchema2(),
+      endedAt: Type.Number()
+    }),
+    Type.Object({ ...common, ...PART, change: Type.Literal("failed"), failure: FailureType2 }),
+    Type.Object({
+      ...common,
+      ...PART,
+      change: Type.Literal("answered"),
+      answer: Type.Object({ action: Type.String(), input: JsonType2 })
+    }),
+    Type.Object({ ...common, ...PART, change: Type.Literal("closed") }),
+    Type.Object({ ...common, ...CALL, change: Type.Literal("intent") }),
+    Type.Object({ ...common, ...CALL, change: Type.Literal("waiting"), on: WaitTargetType2 }),
+    Type.Object({
+      ...common,
+      ...CALL,
+      change: Type.Literal("settled"),
+      outcome: ToolOutcomeType2,
+      changes: CHANGES
+    }),
+    Type.Object({ ...common, kind: Type.Literal("background"), item: BackgroundItemType2 }),
+    Type.Object({
+      ...common,
+      kind: Type.Literal("configured"),
+      selected: nullable2(ConfigurationType2),
+      effective: nullable2(ConfigurationType2)
+    }),
+    Type.Object({
+      ...common,
+      kind: Type.Literal("request"),
+      usage: UsageType2,
+      context: ContextViewType2,
+      step: Type.Enum(["assistant", "compaction", "summary", "plugin"])
+    }),
+    Type.Object({ ...common, kind: Type.Literal("changes"), files: Type.Array(FileChangeType2) }),
+    Type.Object({ ...common, kind: Type.Literal("session"), info: SessionInfoType2 }),
+    Type.Object({ ...common, kind: Type.Literal("activation"), activation: ActivationType2 }),
+    Type.Object({ ...common, kind: Type.Literal("catalog"), catalog: SessionCatalogViewType2 })
+  ]);
+}
+var DurableEventType2 = durableEvent({ head: nullable2(idSchema2()) });
+var SessionEventType2 = durableEvent({
+  seq: SeqType2,
+  at: Type.Number(),
+  head: nullable2(idSchema2())
+});
+var PatchEventType2 = Type.Union([
+  Type.Object({ ...PATCH, append: Type.String() }),
+  Type.Object({ ...PATCH, markdown: Type.String() }),
+  Type.Object({ ...PATCH, progress: ToolProgressType2 })
+]);
+var CommitBodySchema2 = standard2(CommitBodyType2);
+var DurableEventSchema2 = standard2(withJson2(DurableEventType2));
+var SessionEventSchema2 = standard2(withJson2(SessionEventType2));
+var PatchEventSchema2 = standard2(withJson2(PatchEventType2));
+
+export { CommitBodyType2, DurableEventType2, SessionEventType2, PatchEventType2, CommitBodySchema2, DurableEventSchema2, SessionEventSchema2, PatchEventSchema2 };

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-s7907azt.js

@@ -0,0 +1,118 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  JsonType2,
+  cyclicWithJson2,
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  UsageType2
+} from "./browser-8t9anqfc.js";
+import {
+  ConfigurationType2
+} from "./browser-vapnjwp3.js";
+import {
+  FailureType2
+} from "./browser-1sfp0bcx.js";
+import {
+  JobEndType2
+} from "./browser-40enyw9r.js";
+
+// src/runs.ts
+import { Type } from "typebox";
+var RunViewType2 = Type.Object({
+  id: idSchema2(),
+  head: idSchema2(),
+  startedAt: Type.Number(),
+  attempt: Type.Number(),
+  configuration: ConfigurationType2,
+  origin: Type.Union([
+    Type.Object({ kind: Type.Literal("input"), message: idSchema2() }),
+    Type.Object({ kind: Type.Literal("continuation"), from: Type.Enum(["child", "job", "wake"]) })
+  ])
+});
+var RunEndType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("completed"), usage: UsageType2 }),
+  Type.Object({ kind: Type.Literal("stopped") }),
+  Type.Object({ kind: Type.Literal("failed"), failure: FailureType2 })
+]);
+var DEADLINE = { deadline: Type.Optional(Type.Number()) };
+var WaitTargetType2 = Type.Union([
+  Type.Object({
+    ...DEADLINE,
+    kind: Type.Literal("run"),
+    session: idSchema2(),
+    run: idSchema2()
+  }),
+  Type.Object({ ...DEADLINE, kind: Type.Literal("job"), job: idSchema2() }),
+  Type.Object({ ...DEADLINE, kind: Type.Literal("part"), part: idSchema2() }),
+  Type.Object({ ...DEADLINE, kind: Type.Literal("timer"), until: Type.Number() })
+]);
+var ExecutionType2 = Type.Union([
+  Type.Object({
+    kind: Type.Literal("idle"),
+    lastRun: nullable2(Type.Object({ id: idSchema2(), end: RunEndType2, endedAt: Type.Number() }))
+  }),
+  Type.Object({
+    kind: Type.Literal("live"),
+    run: RunViewType2,
+    phase: Type.Enum(["responding", "executing"]),
+    stopping: Type.Boolean()
+  }),
+  Type.Object({ kind: Type.Literal("waiting"), run: RunViewType2, on: WaitTargetType2 }),
+  Type.Object({
+    kind: Type.Literal("retrying"),
+    run: RunViewType2,
+    until: Type.Number(),
+    reason: Type.String()
+  })
+]);
+var BackgroundItemType2 = Type.Object({
+  kind: Type.Enum(["child", "job", "page"]),
+  id: Type.String(),
+  title: Type.String(),
+  state: Type.Enum(["working", "waiting", "done", "failed"]),
+  startedBy: nullable2(idSchema2())
+});
+var WaitOutcomeType2 = Type.Union([
+  Type.Object({
+    kind: Type.Literal("run"),
+    session: idSchema2(),
+    run: idSchema2(),
+    end: RunEndType2
+  }),
+  Type.Object({ kind: Type.Literal("job"), job: idSchema2(), end: JobEndType2 }),
+  Type.Object({
+    kind: Type.Literal("part"),
+    part: idSchema2(),
+    answer: nullable2(Type.Object({ action: Type.String(), input: JsonType2 }))
+  }),
+  Type.Object({ kind: Type.Literal("timer") }),
+  Type.Object({ kind: Type.Literal("deadline") }),
+  Type.Object({ kind: Type.Literal("input"), message: idSchema2() }),
+  Type.Object({ kind: Type.Literal("all"), outcomes: Type.Array(Type.Ref("WaitOutcome")) }),
+  Type.Object({ kind: Type.Literal("stopped") })
+]);
+var WAIT_OUTCOME = cyclicWithJson2({ WaitOutcome: WaitOutcomeType2 }, "WaitOutcome");
+function stopOutcomeSchema2(outcome) {
+  return standard2(withJson2(Type.Union([
+    Type.Object({ kind: Type.Literal("requested") }),
+    Type.Object({ kind: Type.Literal("settled"), outcome }),
+    Type.Object({ kind: Type.Literal("missing") })
+  ])));
+}
+var RunViewSchema2 = standard2(withJson2(RunViewType2));
+var RunEndSchema2 = standard2(RunEndType2);
+var WaitTargetSchema2 = standard2(WaitTargetType2);
+var ExecutionSchema2 = standard2(withJson2(ExecutionType2));
+var BackgroundItemSchema2 = standard2(BackgroundItemType2);
+var WaitOutcomeSchema2 = standard2(WAIT_OUTCOME);
+
+export { RunViewType2, RunEndType2, WaitTargetType2, ExecutionType2, BackgroundItemType2, WaitOutcomeType2, stopOutcomeSchema2, RunViewSchema2, RunEndSchema2, WaitTargetSchema2, ExecutionSchema2, BackgroundItemSchema2, WaitOutcomeSchema2 };