@gaganref/confect-test 10.3.1-fork.92 → 10.3.1-fork.93

package/src/internal/KernelRefusal.ts

@@ -110,3 +110,163 @@ export const rowPending = (operation: string, row: number) =>
     row,
     message: `The test kernel supplies ${operation} in build-order row ${row}.`,
   });
+
+/**
+ * Snapshot bytes are not a kernel snapshot this kernel reads: an unknown
+ * header, a body that is not the snapshot's JSON, or a value that does not
+ * decode.
+ */
+export class SnapshotMalformed extends Schema.TaggedError<SnapshotMalformed>()(
+  "SnapshotMalformed",
+  { reason: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's body does not hash to the digest its header names, so its bytes
+ * changed after export.
+ */
+export class SnapshotDigestMismatch extends Schema.TaggedError<SnapshotDigestMismatch>()(
+  "SnapshotDigestMismatch",
+  { expected: Schema.String, actual: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's components are not the components registered on the world
+ * restoring it.
+ */
+export class SnapshotComponentMismatch extends Schema.TaggedError<SnapshotComponentMismatch>()(
+  "SnapshotComponentMismatch",
+  {
+    snapshot: Schema.Array(Schema.String),
+    registered: Schema.Array(Schema.String),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A job's test world is named by no world, or by more than one, so the job
+ * could not run under the world that scheduled it.
+ */
+export class SnapshotWorldUnresolved extends Schema.TaggedError<SnapshotWorldUnresolved>()(
+  "SnapshotWorldUnresolved",
+  {
+    name: Schema.String,
+    reason: Schema.Literals(["missing", "ambiguous"]),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A world holds work a snapshot does not carry: attempts held for `apply`, or,
+ * when it restores, commits of its own.
+ */
+export class SnapshotWorldBusy extends Schema.TaggedError<SnapshotWorldBusy>()(
+  "SnapshotWorldBusy",
+  {
+    version: Schema.Int,
+    held: Schema.Array(Schema.String),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot marks a secret the restore was not given, so the raw value its
+ * replay needs is not in memory.
+ */
+export class SnapshotSecretMissing extends Schema.TaggedError<SnapshotSecretMissing>()(
+  "SnapshotSecretMissing",
+  { ref: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A world is running work a snapshot taken or restored now would split: calls
+ * from the test, scheduler walks, or function executions, nested and detached
+ * ones included.
+ */
+export class SnapshotWorldRunning extends Schema.TaggedError<SnapshotWorldRunning>()(
+  "SnapshotWorldRunning",
+  {
+    registry: Schema.Literals(["running", "walks", "functions"]),
+    count: Schema.Int,
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A world has subscribers, whose identity versions a restore would rewind.
+ * Subscriptions are live client state, so a restore needs a world with none.
+ */
+export class SnapshotSubscribed extends Schema.TaggedError<SnapshotSubscribed>()(
+  "SnapshotSubscribed",
+  { subscribers: Schema.Int, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's identity counters stand at or behind an identity its state
+ * already holds, so the next allocation would reuse one.
+ */
+export class SnapshotAllocatorBehind extends Schema.TaggedError<SnapshotAllocatorBehind>()(
+  "SnapshotAllocatorBehind",
+  {
+    allocator: Schema.Literals([
+      "nextDocumentId",
+      "lastCreationTime",
+      "nextAttemptId",
+      "identityEpoch",
+    ]),
+    value: Schema.Finite,
+    required: Schema.Finite,
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot's rows are not what its write log publishes: a row filed under
+ * another table or an unregistered component, a version the log does not give
+ * it, or a log change whose before value is not the row it replaced.
+ */
+export class SnapshotRowInconsistent extends Schema.TaggedError<SnapshotRowInconsistent>()(
+  "SnapshotRowInconsistent",
+  {
+    componentPath: Schema.String,
+    id: Schema.String,
+    reason: Schema.Literals([
+      "id",
+      "component",
+      "log",
+      "row",
+      "systemFields",
+      "duplicate",
+    ]),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot's commit timestamps do not strictly increase through its write
+ * log, or its latest commit timestamp is not the log's last.
+ */
+export class SnapshotTimestampInconsistent extends Schema.TaggedError<SnapshotTimestampInconsistent>()(
+  "SnapshotTimestampInconsistent",
+  { version: Schema.Int, commitTs: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's jobs and job rows disagree: a job with no row, a row with no
+ * job, a job left running, or a target no registered component exports.
+ */
+export class SnapshotJobInconsistent extends Schema.TaggedError<SnapshotJobInconsistent>()(
+  "SnapshotJobInconsistent",
+  {
+    id: Schema.String,
+    reason: Schema.Literals([
+      "row",
+      "untargeted",
+      "inProgress",
+      "component",
+      "function",
+      "duplicate",
+    ]),
+    message: Schema.String,
+  },
+) {}