stitchkit 0.85.2 → 0.87.0

package/dist/index-gskm1k5a.js

@@ -0,0 +1,50 @@
+// src/agent-runtime/sandbox.ts
+import { z } from "zod";
+var AgentSandboxRestrictionSchema = z.enum([
+  "network-denied",
+  "write-contained",
+  "secrets-hidden",
+  "process-contained"
+]);
+var AgentSandboxGradeSchema = z.discriminatedUnion("grade", [
+  z.object({ grade: z.literal("full"), restrictions: z.array(AgentSandboxRestrictionSchema) }).strict(),
+  z.object({
+    grade: z.literal("partial"),
+    restrictions: z.array(AgentSandboxRestrictionSchema),
+    gaps: z.array(AgentSandboxRestrictionSchema)
+  }).strict(),
+  z.object({ grade: z.literal("unavailable"), reason: z.string().min(1) }).strict()
+]);
+var probes = new WeakMap;
+function probeAgentProcessSandbox(sandbox, options = {}) {
+  if (options.refresh)
+    probes.delete(sandbox);
+  const present = probes.get(sandbox);
+  if (present)
+    return present;
+  const pending = Promise.resolve(sandbox.probe()).then((grade) => AgentSandboxGradeSchema.parse(grade));
+  probes.set(sandbox, pending);
+  return pending;
+}
+function missingSandboxRestrictions(grade, required) {
+  if (grade.grade === "unavailable")
+    return required;
+  const present = new Set(grade.restrictions);
+  return required.filter((restriction) => !present.has(restriction));
+}
+async function recordAgentSandboxProbe(input) {
+  const grade = await probeAgentProcessSandbox(input.sandbox);
+  const missing = missingSandboxRestrictions(grade, input.required);
+  await input.store.appendEvent({
+    conversationId: input.conversationId,
+    kind: "sandbox/probed",
+    payload: {
+      result: grade,
+      required: [...input.required],
+      missing: [...missing]
+    }
+  });
+  return grade;
+}
+
+export { AgentSandboxRestrictionSchema, AgentSandboxGradeSchema, probeAgentProcessSandbox, missingSandboxRestrictions, recordAgentSandboxProbe };

package/dist/{index-4hk633vz.js → index-hkm6wysp.js}

@@ -10,7 +10,7 @@ import {
   AgentRunStateSchema,
   AgentTerminalReasonSchema,
   AgentTimestampSchema
-} from "./index-x15ss2dx.js";
+} from "./index-p1b1y93x.js";
 
 // src/agent-runtime/event-schema.ts
 import { z } from "zod";
@@ -51,6 +51,12 @@ var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.exten
 var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
   type: z.literal("reasoning-end")
 });
+var AgentAttemptResetEventSchema = EventIdentitySchema.extend({
+  type: z.literal("attempt-reset"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  attempt: z.int().positive()
+});
 var AgentCheckpointEventSchema = EventIdentitySchema.extend({
   type: z.literal("assistant-checkpoint"),
   eventId: AgentRecordIdSchema,
@@ -95,6 +101,7 @@ var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
   AgentReasoningStartEventSchema,
   AgentReasoningDeltaEventSchema,
   AgentReasoningEndEventSchema,
+  AgentAttemptResetEventSchema,
   AgentCheckpointEventSchema,
   AgentRunStateEventSchema,
   AgentRunOperationEventSchema,
@@ -140,4 +147,4 @@ function agentDurableEventId(type, runId, snapshotVersion) {
   return `${runId}:${type}:${snapshotVersion}`;
 }
 
-export { AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentRunOperationEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId };
+export { AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentAttemptResetEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentRunOperationEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId };

package/dist/{index-dx9xehwt.js → index-kc6h6hg0.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-mgtxfe6b.js";
+} from "./index-r159gjwy.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {

package/dist/{index-x15ss2dx.js → index-p1b1y93x.js}

@@ -184,6 +184,9 @@ var AgentTerminalReasonSchema = z.enum([
   "shutdown",
   "provider_failure",
   "context_overflow",
+  "storage_conflict",
+  "output_rejected",
+  "runtime_failure",
   "absorbed",
   "abandoned"
 ]);

package/dist/{index-mgtxfe6b.js → index-r159gjwy.js}

@@ -858,11 +858,18 @@ function assertProjectedName(name, serviceName, action, transport, derived) {
 function projectToolSurface(surface, transport, config = {}) {
   const projected = [];
   const names = new Set;
+  const origins = new Map;
   const append = (tool) => {
     if (config.assertUniqueNames ?? true) {
-      assertUniqueToolName(tool.name, names.has(tool.name), duplicateLabel(transport));
+      if (names.has(tool.name)) {
+        const previous = origins.get(tool.name) ?? "unknown";
+        const current = `${tool.serviceName}.${tool.action}`;
+        throw new Error(`Duplicate ${duplicateLabel(transport)} "${tool.name}" across mounted operations: ${previous}, ${current}`);
+      }
+      assertUniqueToolName(tool.name, false, duplicateLabel(transport));
     }
     names.add(tool.name);
+    origins.set(tool.name, `${tool.serviceName}.${tool.action}`);
     projected.push(tool);
   };
   for (const service of surface.services ?? []) {

package/dist/{index-s4ckmrac.js → index-rcgsnrr6.js}

@@ -1,12 +1,12 @@
 import {
   runtimeToolMountable
-} from "./index-dx9xehwt.js";
+} from "./index-kc6h6hg0.js";
 import {
   contractToolMountable
-} from "./index-fwbkp2jn.js";
+} from "./index-0vfdh685.js";
 import {
   projectToolSurface
-} from "./index-mgtxfe6b.js";
+} from "./index-r159gjwy.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-dggwnnjv.js → index-wn9cb82y.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-vsbzgd7b.js";
 import {
   objectShapeKeys
-} from "./index-mgtxfe6b.js";
+} from "./index-r159gjwy.js";
 import {
   coerceJsonArgs
 } from "./index-7zbps32p.js";

package/dist/index-z1m86vc8.js

@@ -0,0 +1,334 @@
+import {
+  AgentMessageSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunOperationSchema,
+  AgentRunSchema,
+  AgentSnapshotSchema,
+  AgentTerminalReasonSchema,
+  AgentUsageSchema
+} from "./index-p1b1y93x.js";
+
+// src/agent-runtime/history-chronology.ts
+function createToolChronology() {
+  return { calls: new Map, approvals: new Map, pending: 0, resultsStarted: false };
+}
+function advanceToolChronology(previous, parts) {
+  const calls = new Map(previous.calls);
+  const approvals = new Map(previous.approvals);
+  let { pending, resultsStarted } = previous;
+  for (const part of parts) {
+    if (part.type === "tool-call") {
+      if (calls.has(part.callId) || resultsStarted && pending > 0)
+        return;
+      if (pending === 0)
+        resultsStarted = false;
+      calls.set(part.callId, { toolName: part.toolName, phase: "called" });
+      pending += 1;
+    } else if (part.type === "tool-approval-request") {
+      const call = calls.get(part.callId);
+      if (call?.phase !== "called" || approvals.has(part.approvalId))
+        return;
+      approvals.set(part.approvalId, part.callId);
+      calls.set(part.callId, { ...call, phase: "requested" });
+    } else if (part.type === "tool-approval-response") {
+      const callId = approvals.get(part.approvalId);
+      const call = callId === undefined ? undefined : calls.get(callId);
+      if (callId === undefined || !call || call.phase !== "requested")
+        return;
+      calls.set(callId, { ...call, phase: part.approved ? "approved" : "denied" });
+    } else if (part.type === "tool-result") {
+      const call = calls.get(part.callId);
+      if (!call || call.toolName !== part.toolName || call.phase === "result" || call.phase === "requested" || call.phase === "denied" && part.outcome === "success")
+        return;
+      calls.set(part.callId, { ...call, phase: "result" });
+      pending -= 1;
+      resultsStarted = true;
+    }
+  }
+  return { calls, approvals, pending, resultsStarted };
+}
+function canProjectToolChronology(state) {
+  return [...state.calls.values()].every(({ phase }) => phase !== "called");
+}
+
+// src/agent-runtime/terminal-status.ts
+function isSpeakableAssistantStatus(status) {
+  return status === "completed" || status === "interrupted" || status === "committed";
+}
+function isAssistantHistoryEvidence(status, policy) {
+  return isSpeakableAssistantStatus(status) || status === "failed" && policy?.failedAssistant === "assistant-marked";
+}
+function isCompleteAgentHistoryTurn(messages, policy) {
+  if (messages[0]?.role !== "user")
+    return false;
+  let chronology = createToolChronology();
+  let assistantCount = 0;
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      if (!isAssistantHistoryEvidence(message.status, policy))
+        return false;
+      assistantCount += 1;
+    }
+    const next = advanceToolChronology(chronology, message.parts);
+    if (!next)
+      return false;
+    chronology = next;
+  }
+  return assistantCount > 0 && chronology.pending === 0;
+}
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
+    return "completed";
+  }
+  if (reason === "superseded")
+    return "superseded";
+  if (reason === "absorbed")
+    return "superseded";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+
+// src/agent-runtime/store.ts
+import { z } from "zod";
+var AgentStoreConflictSchema = z.object({
+  outcome: z.literal("conflict"),
+  actualVersion: AgentRecordVersionSchema
+});
+var AgentStoreNotFoundSchema = z.object({ outcome: z.literal("not_found") });
+var AgentStoreAppliedSchema = z.object({
+  outcome: z.literal("applied"),
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreDuplicateSchema = z.object({
+  outcome: z.literal("duplicate"),
+  input: AgentMessageSchema,
+  inputMessageId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional(),
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreMutationResultSchema = z.discriminatedUnion("outcome", [
+  AgentStoreAppliedSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreConflictSchema,
+  AgentStoreNotFoundSchema
+]);
+var AgentRunViewSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional()
+});
+var AcceptInputAndAssignRunSchema = z.object({
+  idempotencyKey: z.string().min(1),
+  expectedVersion: AgentRecordVersionSchema.optional(),
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  coalesceIntoRunId: AgentRecordIdSchema.optional()
+});
+var AcquireAgentRunSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1)
+});
+var CheckpointRunAssistantSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  assistant: AgentMessageSchema,
+  usage: AgentUsageSchema.optional()
+});
+var RecordRunOperationSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  operation: AgentRunOperationSchema
+});
+var CommitRunTerminalSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  assistant: AgentMessageSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z.string().min(1).optional(),
+  usage: AgentUsageSchema.optional(),
+  absorb: z.array(z.object({
+    runId: AgentRecordIdSchema,
+    inputMessageIds: z.array(AgentRecordIdSchema).min(1)
+  })).min(1).optional()
+});
+var RequestRunInterruptSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema
+});
+var RecoverAgentRunSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  action: z.enum(["requeue", "abandon"]),
+  replaySafe: z.boolean().optional()
+});
+var ReplaceCompactedRangeSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema,
+  replacedMessageIds: z.array(AgentRecordIdSchema).min(1),
+  summary: AgentMessageSchema
+});
+var AgentRecoverableDescriptorSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  run: AgentRunSchema
+});
+var AgentRecoverablePageSchema = z.object({
+  items: z.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z.string().min(1).optional()
+});
+
+// src/agent-runtime/store-events.ts
+import { randomUUID } from "node:crypto";
+import { z as z2 } from "zod";
+var AgentStoreEventKindSchema = z2.enum([
+  "runtime/baseline",
+  "runtime/transition",
+  "provider/request",
+  "provider/message",
+  "state/set",
+  "spill/created",
+  "spill/deleted",
+  "schedule/set",
+  "schedule/fired",
+  "schedule/cancelled",
+  "schedule/late",
+  "schedule/failed",
+  "child/spawned",
+  "child/state",
+  "retry/scheduled",
+  "retry/started",
+  "sandbox/probed"
+]);
+var AgentStoreTransitionSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("accept"), input: AcceptInputAndAssignRunSchema }).strict(),
+  z2.object({ type: z2.literal("acquire"), input: AcquireAgentRunSchema }).strict(),
+  z2.object({ type: z2.literal("checkpoint"), input: CheckpointRunAssistantSchema }).strict(),
+  z2.object({ type: z2.literal("operation"), input: RecordRunOperationSchema }).strict(),
+  z2.object({ type: z2.literal("interrupt"), input: RequestRunInterruptSchema }).strict(),
+  z2.object({ type: z2.literal("recover"), input: RecoverAgentRunSchema }).strict(),
+  z2.object({ type: z2.literal("terminal"), input: CommitRunTerminalSchema }).strict(),
+  z2.object({ type: z2.literal("compact"), input: ReplaceCompactedRangeSchema }).strict()
+]);
+var AgentStoreEventEnvelopeSchema = z2.object({
+  schemaVersion: z2.int().positive(),
+  eventId: z2.string().min(1),
+  conversationId: z2.string().min(1),
+  seq: z2.int().positive(),
+  kind: z2.string().min(1),
+  occurredAt: z2.iso.datetime({ offset: true }),
+  payload: z2.json(),
+  ignorable: z2.literal(true).optional()
+}).strict();
+var AppendAgentStoreEventSchema = z2.object({
+  conversationId: z2.string().min(1),
+  kind: AgentStoreEventKindSchema,
+  occurredAt: z2.iso.datetime({ offset: true }).optional(),
+  payload: z2.json(),
+  ignorable: z2.literal(true).optional()
+}).strict();
+var ReadAgentStoreEventsSchema = z2.object({
+  conversationId: z2.string().min(1),
+  fromSeq: z2.int().positive().optional(),
+  toSeq: z2.int().positive().optional(),
+  limit: z2.int().positive().max(1e4).default(1000)
+}).strict().refine((input) => input.fromSeq === undefined || input.toSeq === undefined || input.fromSeq <= input.toSeq, { message: "fromSeq must not exceed toSeq" });
+var AgentStoreEventPageSchema = z2.object({
+  items: z2.array(AgentStoreEventEnvelopeSchema),
+  nextSeq: z2.int().positive().optional()
+}).strict();
+var CURRENT_EVENT_SCHEMA_VERSION = 1;
+function decodeAgentStoreEvent(value) {
+  const envelope = AgentStoreEventEnvelopeSchema.parse(value);
+  const knownVersion = envelope.schemaVersion === CURRENT_EVENT_SCHEMA_VERSION;
+  const knownKind = AgentStoreEventKindSchema.safeParse(envelope.kind).success;
+  if (knownVersion && knownKind)
+    return { outcome: "accepted", event: envelope };
+  if (!envelope.ignorable) {
+    throw new TypeError(`Unsupported agent store event at ${envelope.conversationId}:${envelope.seq} ` + `(${envelope.eventId}): schema ${envelope.schemaVersion}, kind ${envelope.kind}`);
+  }
+  return {
+    outcome: "ignored",
+    eventId: envelope.eventId,
+    conversationId: envelope.conversationId,
+    seq: envelope.seq,
+    schemaVersion: envelope.schemaVersion,
+    kind: envelope.kind
+  };
+}
+function agentStoreEventDraft(input) {
+  const parsed = AppendAgentStoreEventSchema.parse(input);
+  return {
+    schemaVersion: CURRENT_EVENT_SCHEMA_VERSION,
+    eventId: randomUUID(),
+    conversationId: parsed.conversationId,
+    kind: parsed.kind,
+    occurredAt: parsed.occurredAt ?? new Date().toISOString(),
+    payload: parsed.payload,
+    ...parsed.ignorable && { ignorable: true }
+  };
+}
+function canonicalJsonValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJsonValue).join(",")}]`;
+  const record = z2.record(z2.string(), z2.json()).parse(value);
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonValue(record[key])}`).join(",")}}`;
+}
+function canonicalAgentJson(value) {
+  return canonicalJsonValue(z2.json().parse(value));
+}
+var AgentConversationArchiveSchema = z2.object({
+  format: z2.literal("stitchkit.agent-conversation"),
+  formatVersion: z2.literal(1),
+  conversationId: z2.string().min(1),
+  events: z2.array(AgentStoreEventEnvelopeSchema),
+  projections: z2.array(z2.json()).default([]),
+  spills: z2.array(z2.json()).default([])
+}).strict();
+function encodeAgentConversationArchive(archive) {
+  const parsed = AgentConversationArchiveSchema.parse(archive);
+  return new TextEncoder().encode(canonicalAgentJson(parsed));
+}
+function decodeAgentConversationArchive(bytes) {
+  const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  const archive = AgentConversationArchiveSchema.parse(value);
+  let previous = 0;
+  const ids = new Set;
+  for (const event of archive.events) {
+    if (event.conversationId !== archive.conversationId) {
+      throw new TypeError("Conversation archive contains an event for another conversation");
+    }
+    if (event.seq <= previous)
+      throw new TypeError("Conversation archive event sequence is not increasing");
+    if (ids.has(event.eventId))
+      throw new TypeError("Conversation archive contains a duplicate event id");
+    decodeAgentStoreEvent(event);
+    previous = event.seq;
+    ids.add(event.eventId);
+  }
+  return archive;
+}
+
+export { createToolChronology, advanceToolChronology, canProjectToolChronology, isAssistantHistoryEvidence, isCompleteAgentHistoryTurn, assistantStatus, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, RecordRunOperationSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentStoreEventKindSchema, AgentStoreTransitionSchema, AgentStoreEventEnvelopeSchema, AppendAgentStoreEventSchema, ReadAgentStoreEventsSchema, AgentStoreEventPageSchema, decodeAgentStoreEvent, agentStoreEventDraft, canonicalAgentJson, AgentConversationArchiveSchema, encodeAgentConversationArchive, decodeAgentConversationArchive };

package/dist/{index-ff0kcqvp.js → index-z2452tsw.js}

@@ -1,10 +1,10 @@
 import {
   AgentRuntimeEventSchema
-} from "./index-4hk633vz.js";
+} from "./index-hkm6wysp.js";
 import {
   AgentMessagePartSchema,
   AgentSnapshotSchema
-} from "./index-x15ss2dx.js";
+} from "./index-p1b1y93x.js";
 
 // src/agent-runtime/control-schema.ts
 import { z } from "zod";
@@ -179,7 +179,7 @@ function reduceAgentControlEvent(view, rawEvent) {
     };
   }
   const transient = current.transientByRun[event.runId] ?? { text: "", reasoning: "" };
-  const nextTransient = event.type === "assistant-delta" ? { ...transient, text: transient.text + event.textDelta } : event.type === "reasoning-delta" ? { ...transient, reasoning: transient.reasoning + event.textDelta } : transient;
+  const nextTransient = event.type === "assistant-delta" ? { ...transient, text: transient.text + event.textDelta } : event.type === "reasoning-delta" ? { ...transient, reasoning: transient.reasoning + event.textDelta } : event.type === "attempt-reset" ? { text: "", reasoning: "" } : transient;
   const snapshotStale = durable(event) && current.snapshot?.version !== event.snapshotVersion;
   const transientByRun = event.type === "terminal" ? Object.fromEntries(Object.entries(current.transientByRun).filter(([runId]) => runId !== event.runId)) : { ...current.transientByRun, [event.runId]: nextTransient };
   return {

package/dist/internal/sqlite.d.ts

@@ -15,6 +15,19 @@ export type SqliteValue = string | number | bigint | null | Uint8Array;
 export interface SqliteStatement {
     get(...parameters: SqliteValue[]): unknown;
     all(...parameters: SqliteValue[]): readonly unknown[];
+    /**
+     * `changes` is the driver's own count and is advisory: never decide
+     * correctness by it.
+     *
+     * Because this boundary is satisfied structurally by a raw handle, the
+     * number is whatever that driver reports. `bun:sqlite` includes rows written
+     * by an AFTER INSERT trigger and by FTS5's deferred index flush during the
+     * same statement, so a statement that moved one row can report five, and one
+     * that moved none can report more than zero. A guarded `UPDATE`/upsert whose
+     * outcome is read back from `changes` is therefore not a compare-and-swap.
+     * Read the row, compare, then write unconditionally — inside the store's
+     * `BEGIN IMMEDIATE` transaction that is atomic.
+     */
     run(...parameters: SqliteValue[]): {
         changes: number;
     };

package/dist/internal/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/internal/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC;AAEvE,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IAC3C,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG,SAAS,OAAO,EAAE,CAAC;IACtD,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACxD;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IACtC,KAAK,IAAI,IAAI,CAAC;CACf"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/internal/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,UAAU,CAAC;AAEvE,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IAC3C,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG,SAAS,OAAO,EAAE,CAAC;IACtD;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,UAAU,EAAE,WAAW,EAAE,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACxD;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IACtC,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/testing/agent-store-conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAkCf"}
+{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIhE;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAoCf"}