@crvouga/mockingbird-service-posthog 2.1.0 → 2.3.0

package/dist/server.d.ts

@@ -1,6 +1,125 @@
 import { Server } from 'node:http';
 import { Hono } from 'hono';
 
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue$2 = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult$2 = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement$2 {
+    run(...params: SqliteValue$2[]): SqliteRunResult$2;
+    all<T = Record<string, unknown>>(...params: SqliteValue$2[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$2[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient$2 {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement$2;
+    transaction<T>(fn: () => T): T;
+}
+
+/** A stable identifier for a point in a {@link Timeline}. */
+type CheckpointId$1 = string;
+/** An immutable node in a timeline's checkpoint DAG. */
+type Checkpoint$1<T> = Readonly<{
+    id: CheckpointId$1;
+    branch: string;
+    parent: CheckpointId$1 | null;
+    /** Logical time supplied by the timeline's injected clock. */
+    at: number;
+    value: T;
+}>;
+type TimelineOptions$1 = {
+    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
+    now?: () => number;
+    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
+    maxCheckpoints?: number;
+    /** Customize deterministic checkpoint IDs. */
+    id?: (sequence: number) => CheckpointId$1;
+};
+type CommitOptions$1 = {
+    branch?: string;
+    /** Parent checkpoint. Defaults to the selected branch's current head. */
+    parent?: CheckpointId$1 | null;
+};
+type ForkOptions$1 = {
+    /** Checkpoint to fork from. Defaults to the main branch's head. */
+    from?: CheckpointId$1;
+};
+/**
+ * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
+ * records, namespace images, or copy-on-write SQL engine snapshots.
+ *
+ * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
+ * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
+ * (the logical clock) is injected.
+ */
+declare class Timeline$1<T> {
+    readonly maxCheckpoints: number;
+    private readonly now;
+    private readonly makeId;
+    private readonly nodes;
+    private readonly heads;
+    /** Unreferenced nodes in the exact order they became collectible. */
+    private readonly evictable;
+    /** Branch heads plus explicit retainers. Absent means zero. */
+    private readonly references;
+    private readonly explicitPins;
+    private sequence;
+    constructor(options?: TimelineOptions$1);
+    /** Capture a new immutable value and move `branch` to it. */
+    commit(value: T, options?: CommitOptions$1): Checkpoint$1<T>;
+    /** Create a branch pointer without copying its checkpoint value. */
+    fork(branch: string, options?: ForkOptions$1): Checkpoint$1<T> | undefined;
+    /** Move a branch pointer to an existing checkpoint. */
+    checkout(branch: string, id: CheckpointId$1): Checkpoint$1<T>;
+    get(id: CheckpointId$1): Checkpoint$1<T>;
+    head(branch?: string): Checkpoint$1<T> | undefined;
+    hasBranch(branch: string): boolean;
+    branches(): Readonly<Record<string, CheckpointId$1>>;
+    checkpoints(): readonly Checkpoint$1<T>[];
+    /** Number of retained checkpoints without allocating an array. */
+    get size(): number;
+    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+    retain(id: CheckpointId$1): Checkpoint$1<T>;
+    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+    release(id: CheckpointId$1): boolean;
+    deleteBranch(branch: string): boolean;
+    /**
+     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+     * storage dependency, so a retained node remains usable after pruning.
+     */
+    gc(max?: number): CheckpointId$1[];
+    private collect;
+    private moveHead;
+    private addReference;
+    private removeReference;
+    private assertBranch;
+}
+
+/**
+ * Anything that can answer a Fetch `Request` with a `Response`.
+ *
+ * Every Mockingbird service implements this, and every runtime adapter consumes it.
+ * It is the only contract shared across the whole graph.
+ */
+interface FetchAPI$2 {
+    fetch(request: Request): Promise<Response>;
+}
+
 /**
  * The single source of time for a service.
  *
@@ -31,35 +150,6 @@ type Clock$1 = {
     state(): ClockState$1;
 };
 
-/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
-type SqliteValue$2 = null | number | bigint | string | Uint8Array | boolean;
-/** Mutation counters returned by {@link SqliteStatement.run}. */
-type SqliteRunResult$2 = {
-    changes: number;
-    lastInsertRowid: number | bigint;
-};
-/**
- * Prepared statement bound to a {@link SqliteClient}.
- *
- * Pass bind values as rest arguments on each call (no sticky `bind()`).
- */
-interface SqliteStatement$2 {
-    run(...params: SqliteValue$2[]): SqliteRunResult$2;
-    all<T = Record<string, unknown>>(...params: SqliteValue$2[]): T[];
-    get<T = Record<string, unknown>>(...params: SqliteValue$2[]): T | undefined;
-}
-/**
- * Sync SQLite client port owned by Mockingbird.
- *
- * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
- * `bun:sqlite` instances all work when they expose this surface.
- */
-interface SqliteClient$2 {
-    exec(sql: string): void;
-    prepare(sql: string): SqliteStatement$2;
-    transaction<T>(fn: () => T): T;
-}
-
 /**
  * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
  * request a percentage fault hits — is reproducible from a seed.
@@ -187,96 +277,6 @@ type FaultRegistry$1 = {
     take(candidate: FaultCandidate$1): Promise<FaultHit$1[]>;
 };
 
-/** A stable identifier for a point in a {@link Timeline}. */
-type CheckpointId$1 = string;
-/** An immutable node in a timeline's checkpoint DAG. */
-type Checkpoint$1<T> = Readonly<{
-    id: CheckpointId$1;
-    branch: string;
-    parent: CheckpointId$1 | null;
-    /** Logical time supplied by the timeline's injected clock. */
-    at: number;
-    value: T;
-}>;
-type TimelineOptions$1 = {
-    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
-    now?: () => number;
-    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
-    maxCheckpoints?: number;
-    /** Customize deterministic checkpoint IDs. */
-    id?: (sequence: number) => CheckpointId$1;
-};
-type CommitOptions$1 = {
-    branch?: string;
-    /** Parent checkpoint. Defaults to the selected branch's current head. */
-    parent?: CheckpointId$1 | null;
-};
-type ForkOptions$1 = {
-    /** Checkpoint to fork from. Defaults to the main branch's head. */
-    from?: CheckpointId$1;
-};
-/**
- * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
- * records, namespace images, or copy-on-write SQL engine snapshots.
- *
- * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
- * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
- * (the logical clock) is injected.
- */
-declare class Timeline$1<T> {
-    readonly maxCheckpoints: number;
-    private readonly now;
-    private readonly makeId;
-    private readonly nodes;
-    private readonly heads;
-    /** Unreferenced nodes in the exact order they became collectible. */
-    private readonly evictable;
-    /** Branch heads plus explicit retainers. Absent means zero. */
-    private readonly references;
-    private readonly explicitPins;
-    private sequence;
-    constructor(options?: TimelineOptions$1);
-    /** Capture a new immutable value and move `branch` to it. */
-    commit(value: T, options?: CommitOptions$1): Checkpoint$1<T>;
-    /** Create a branch pointer without copying its checkpoint value. */
-    fork(branch: string, options?: ForkOptions$1): Checkpoint$1<T> | undefined;
-    /** Move a branch pointer to an existing checkpoint. */
-    checkout(branch: string, id: CheckpointId$1): Checkpoint$1<T>;
-    get(id: CheckpointId$1): Checkpoint$1<T>;
-    head(branch?: string): Checkpoint$1<T> | undefined;
-    hasBranch(branch: string): boolean;
-    branches(): Readonly<Record<string, CheckpointId$1>>;
-    checkpoints(): readonly Checkpoint$1<T>[];
-    /** Number of retained checkpoints without allocating an array. */
-    get size(): number;
-    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
-    retain(id: CheckpointId$1): Checkpoint$1<T>;
-    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
-    release(id: CheckpointId$1): boolean;
-    deleteBranch(branch: string): boolean;
-    /**
-     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
-     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
-     * storage dependency, so a retained node remains usable after pruning.
-     */
-    gc(max?: number): CheckpointId$1[];
-    private collect;
-    private moveHead;
-    private addReference;
-    private removeReference;
-    private assertBranch;
-}
-
-/**
- * Anything that can answer a Fetch `Request` with a `Response`.
- *
- * Every Mockingbird service implements this, and every runtime adapter consumes it.
- * It is the only contract shared across the whole graph.
- */
-interface FetchAPI$2 {
-    fetch(request: Request): Promise<Response>;
-}
-
 /**
  * One problem with a request body, at a dotted path (`patient.address.city`, `items.0.sku`).
  * `kind` is `media_type` when the body is present but its media type is not one the operation
@@ -318,6 +318,10 @@ type RequestLog$1 = {
     ids?: Record<string, string>;
     /** Set when the service created a resource the request referred to but that did not exist. */
     adopted?: boolean;
+    /** Explicit durable acceptance, independent of response delivery. */
+    accepted?: boolean;
+    /** Checkpoint captured at explicit acceptance. */
+    checkpoint?: string;
     /** Set on a rejection (status ≥ 400) the mock produced itself, never on a scripted fault. */
     request?: RejectedRequest$1;
     /** The validation issues behind a rejection, when the service found any. */
@@ -584,35 +588,221 @@ type Listening = {
     close(): Promise<void>;
 };
 
-type CliOption = {
-    type: "string" | "boolean";
-    description: string;
-    /** Shown in help; the value placeholder, e.g. `<port>`. */
-    value?: string;
-    default?: string | boolean;
-};
-type CliValues = Record<string, string | boolean | undefined>;
-type CommonServeOptions = {
-    adminPrefix?: string;
-    adminKey: string | undefined;
-    seed: string | undefined;
-    onLog: ((entry: RequestLog$1) => void) | undefined;
-};
+type CliOption = {
+    type: "string" | "boolean";
+    description: string;
+    /** Shown in help; the value placeholder, e.g. `<port>`. */
+    value?: string;
+    default?: string | boolean;
+};
+type CliValues = Record<string, string | boolean | undefined>;
+type CommonServeOptions = {
+    adminPrefix?: string;
+    adminKey: string | undefined;
+    seed: string | undefined;
+    onLog: ((entry: RequestLog$1) => void) | undefined;
+};
+/**
+ * What a service contributes to `serve`: how to build its runtime from CLI flags,
+ * and what to say at startup. Every service's `./server` entry exports one as
+ * `serveTarget`, which is also how `serve --config` finds services by name.
+ */
+type ServeTarget = {
+    name: string;
+    defaultPort: number;
+    /** Serve flags beyond the common ones. */
+    options?: Record<string, CliOption>;
+    create(values: CliValues, common: CommonServeOptions): Promise<ServiceRuntime$1<ServiceInstance$1>> | ServiceRuntime$1<ServiceInstance$1>;
+    /** Startup lines after the listen address, e.g. the loaded corpus version. */
+    banner?(runtime: ServiceRuntime$1<ServiceInstance$1>): string[];
+    /** After the HTTP server is bound. A service that speaks more than HTTP attaches it here. */
+    listening?(server: Listening): void;
+};
+
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult$1 = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement$1 {
+    run(...params: SqliteValue$1[]): SqliteRunResult$1;
+    all<T = Record<string, unknown>>(...params: SqliteValue$1[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$1[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient$1 {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement$1;
+    transaction<T>(fn: () => T): T;
+}
+
+/** Every stored record carries a monotonically increasing sequence for stable ordering. */
+type Stored<T> = {
+    seq: number;
+    value: T;
+};
+type ListRecordsOptions<T> = {
+    /** Keep only records passing the predicate. */
+    where?: (value: T, seq: number) => boolean;
+    /** Sort order; default newest first. */
+    order?: "newest" | "oldest";
+};
+/**
+ * A SQLite-backed table of JSON records addressed by id. Ordering is by insertion
+ * sequence, never by id lexicographic order, so list semantics stay stable.
+ */
+declare class Collection<T> {
+    private readonly sqlite;
+    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
+    readonly namespace: string;
+    /** Table name inside the namespace. Stable across resets of the rows themselves. */
+    readonly collectionName: string;
+    constructor(sqlite: SqliteClient$1, 
+    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
+    namespace: string, 
+    /** Table name inside the namespace. Stable across resets of the rows themselves. */
+    collectionName: string);
+    private bumpCollectionSeq;
+    nextSequence(): number;
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    /** Insert a new record, assigning it the next sequence number. */
+    insert(id: string, value: T): Stored<T>;
+    /** Replace an existing record's value, keeping its position. */
+    update(id: string, value: T): Stored<T> | undefined;
+    delete(id: string): boolean;
+    /** How many records the collection holds, without reading them. */
+    count(): number;
+    list(options?: ListRecordsOptions<T>): Array<Stored<T> & {
+        id: string;
+    }>;
+}
+
+/**
+ * Sequential id source persisted in SQLite. Ids are deterministic for a given
+ * sequence history (`cus_` + 14 opaque chars), so reproductions stay stable.
+ */
+declare class IdSequence {
+    private readonly sqlite;
+    private readonly namespace;
+    private readonly salt;
+    constructor(sqlite: SqliteClient$1, namespace: string, salt?: string);
+    next(prefix: string, length?: number): string;
+}
+
+/** A stable identifier for a point in a {@link Timeline}. */
+type CheckpointId = string;
+/** An immutable node in a timeline's checkpoint DAG. */
+type Checkpoint<T> = Readonly<{
+    id: CheckpointId;
+    branch: string;
+    parent: CheckpointId | null;
+    /** Logical time supplied by the timeline's injected clock. */
+    at: number;
+    value: T;
+}>;
+type TimelineOptions = {
+    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
+    now?: () => number;
+    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
+    maxCheckpoints?: number;
+    /** Customize deterministic checkpoint IDs. */
+    id?: (sequence: number) => CheckpointId;
+};
+type CommitOptions = {
+    branch?: string;
+    /** Parent checkpoint. Defaults to the selected branch's current head. */
+    parent?: CheckpointId | null;
+};
+type ForkOptions = {
+    /** Checkpoint to fork from. Defaults to the main branch's head. */
+    from?: CheckpointId;
+};
+/**
+ * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
+ * records, namespace images, or copy-on-write SQL engine snapshots.
+ *
+ * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
+ * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
+ * (the logical clock) is injected.
+ */
+declare class Timeline<T> {
+    readonly maxCheckpoints: number;
+    private readonly now;
+    private readonly makeId;
+    private readonly nodes;
+    private readonly heads;
+    /** Unreferenced nodes in the exact order they became collectible. */
+    private readonly evictable;
+    /** Branch heads plus explicit retainers. Absent means zero. */
+    private readonly references;
+    private readonly explicitPins;
+    private sequence;
+    constructor(options?: TimelineOptions);
+    /** Capture a new immutable value and move `branch` to it. */
+    commit(value: T, options?: CommitOptions): Checkpoint<T>;
+    /** Create a branch pointer without copying its checkpoint value. */
+    fork(branch: string, options?: ForkOptions): Checkpoint<T> | undefined;
+    /** Move a branch pointer to an existing checkpoint. */
+    checkout(branch: string, id: CheckpointId): Checkpoint<T>;
+    get(id: CheckpointId): Checkpoint<T>;
+    head(branch?: string): Checkpoint<T> | undefined;
+    hasBranch(branch: string): boolean;
+    branches(): Readonly<Record<string, CheckpointId>>;
+    checkpoints(): readonly Checkpoint<T>[];
+    /** Number of retained checkpoints without allocating an array. */
+    get size(): number;
+    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+    retain(id: CheckpointId): Checkpoint<T>;
+    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+    release(id: CheckpointId): boolean;
+    deleteBranch(branch: string): boolean;
+    /**
+     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+     * storage dependency, so a retained node remains usable after pruning.
+     */
+    gc(max?: number): CheckpointId[];
+    private collect;
+    private moveHead;
+    private addReference;
+    private removeReference;
+    private assertBranch;
+}
+
 /**
- * What a service contributes to `serve`: how to build its runtime from CLI flags,
- * and what to say at startup. Every service's `./server` entry exports one as
- * `serveTarget`, which is also how `serve --config` finds services by name.
+ * Anything that can answer a Fetch `Request` with a `Response`.
+ *
+ * Every Mockingbird service implements this, and every runtime adapter consumes it.
+ * It is the only contract shared across the whole graph.
  */
-type ServeTarget = {
-    name: string;
-    defaultPort: number;
-    /** Serve flags beyond the common ones. */
-    options?: Record<string, CliOption>;
-    create(values: CliValues, common: CommonServeOptions): Promise<ServiceRuntime$1<ServiceInstance$1>> | ServiceRuntime$1<ServiceInstance$1>;
-    /** Startup lines after the listen address, e.g. the loaded corpus version. */
-    banner?(runtime: ServiceRuntime$1<ServiceInstance$1>): string[];
-    /** After the HTTP server is bound. A service that speaks more than HTTP attaches it here. */
-    listening?(server: Listening): void;
+interface FetchAPI$1 {
+    fetch(request: Request): Promise<Response>;
+}
+
+/** Options every provider constructor accepts. */
+type APIOptions = {
+    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
+    sqlite?: SqliteClient$1;
+    /** Clock used for `created`-style fields. Default `Date.now`. */
+    now?: () => number;
+    /**
+     * Storage namespace for this instance's records. Instances sharing one SQLite
+     * client stay isolated when their namespaces differ. Defaults to the service name.
+     */
+    namespace?: string;
 };
 
 /**
@@ -645,77 +835,6 @@ type Clock = {
     state(): ClockState;
 };
 
-/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
-type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
-/** Mutation counters returned by {@link SqliteStatement.run}. */
-type SqliteRunResult$1 = {
-    changes: number;
-    lastInsertRowid: number | bigint;
-};
-/**
- * Prepared statement bound to a {@link SqliteClient}.
- *
- * Pass bind values as rest arguments on each call (no sticky `bind()`).
- */
-interface SqliteStatement$1 {
-    run(...params: SqliteValue$1[]): SqliteRunResult$1;
-    all<T = Record<string, unknown>>(...params: SqliteValue$1[]): T[];
-    get<T = Record<string, unknown>>(...params: SqliteValue$1[]): T | undefined;
-}
-/**
- * Sync SQLite client port owned by Mockingbird.
- *
- * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
- * `bun:sqlite` instances all work when they expose this surface.
- */
-interface SqliteClient$1 {
-    exec(sql: string): void;
-    prepare(sql: string): SqliteStatement$1;
-    transaction<T>(fn: () => T): T;
-}
-
-/** Every stored record carries a monotonically increasing sequence for stable ordering. */
-type Stored<T> = {
-    seq: number;
-    value: T;
-};
-type ListRecordsOptions<T> = {
-    /** Keep only records passing the predicate. */
-    where?: (value: T, seq: number) => boolean;
-    /** Sort order; default newest first. */
-    order?: "newest" | "oldest";
-};
-/**
- * A SQLite-backed table of JSON records addressed by id. Ordering is by insertion
- * sequence, never by id lexicographic order, so list semantics stay stable.
- */
-declare class Collection<T> {
-    private readonly sqlite;
-    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
-    readonly namespace: string;
-    /** Table name inside the namespace. Stable across resets of the rows themselves. */
-    readonly collectionName: string;
-    constructor(sqlite: SqliteClient$1, 
-    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
-    namespace: string, 
-    /** Table name inside the namespace. Stable across resets of the rows themselves. */
-    collectionName: string);
-    private bumpCollectionSeq;
-    nextSequence(): number;
-    get(id: string): T | undefined;
-    has(id: string): boolean;
-    /** Insert a new record, assigning it the next sequence number. */
-    insert(id: string, value: T): Stored<T>;
-    /** Replace an existing record's value, keeping its position. */
-    update(id: string, value: T): Stored<T> | undefined;
-    delete(id: string): boolean;
-    /** How many records the collection holds, without reading them. */
-    count(): number;
-    list(options?: ListRecordsOptions<T>): Array<Stored<T> & {
-        id: string;
-    }>;
-}
-
 /**
  * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
  * request a percentage fault hits — is reproducible from a seed.
@@ -843,109 +962,6 @@ type FaultRegistry = {
     take(candidate: FaultCandidate): Promise<FaultHit[]>;
 };
 
-/** A stable identifier for a point in a {@link Timeline}. */
-type CheckpointId = string;
-/** An immutable node in a timeline's checkpoint DAG. */
-type Checkpoint<T> = Readonly<{
-    id: CheckpointId;
-    branch: string;
-    parent: CheckpointId | null;
-    /** Logical time supplied by the timeline's injected clock. */
-    at: number;
-    value: T;
-}>;
-type TimelineOptions = {
-    /** Logical clock used to stamp checkpoints. Defaults to a deterministic counter. */
-    now?: () => number;
-    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
-    maxCheckpoints?: number;
-    /** Customize deterministic checkpoint IDs. */
-    id?: (sequence: number) => CheckpointId;
-};
-type CommitOptions = {
-    branch?: string;
-    /** Parent checkpoint. Defaults to the selected branch's current head. */
-    parent?: CheckpointId | null;
-};
-type ForkOptions = {
-    /** Checkpoint to fork from. Defaults to the main branch's head. */
-    from?: CheckpointId;
-};
-/**
- * Small, storage-agnostic checkpoint DAG shared by service runtimes. Its values may be immutable
- * records, namespace images, or copy-on-write SQL engine snapshots.
- *
- * Values are retained by reference. Engines can therefore use persistent/COW snapshots while
- * simpler services can use immutable values. IDs and GC order are deterministic, and all IO
- * (the logical clock) is injected.
- */
-declare class Timeline<T> {
-    readonly maxCheckpoints: number;
-    private readonly now;
-    private readonly makeId;
-    private readonly nodes;
-    private readonly heads;
-    /** Unreferenced nodes in the exact order they became collectible. */
-    private readonly evictable;
-    /** Branch heads plus explicit retainers. Absent means zero. */
-    private readonly references;
-    private readonly explicitPins;
-    private sequence;
-    constructor(options?: TimelineOptions);
-    /** Capture a new immutable value and move `branch` to it. */
-    commit(value: T, options?: CommitOptions): Checkpoint<T>;
-    /** Create a branch pointer without copying its checkpoint value. */
-    fork(branch: string, options?: ForkOptions): Checkpoint<T> | undefined;
-    /** Move a branch pointer to an existing checkpoint. */
-    checkout(branch: string, id: CheckpointId): Checkpoint<T>;
-    get(id: CheckpointId): Checkpoint<T>;
-    head(branch?: string): Checkpoint<T> | undefined;
-    hasBranch(branch: string): boolean;
-    branches(): Readonly<Record<string, CheckpointId>>;
-    checkpoints(): readonly Checkpoint<T>[];
-    /** Number of retained checkpoints without allocating an array. */
-    get size(): number;
-    /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
-    retain(id: CheckpointId): Checkpoint<T>;
-    /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
-    release(id: CheckpointId): boolean;
-    deleteBranch(branch: string): boolean;
-    /**
-     * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
-     * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
-     * storage dependency, so a retained node remains usable after pruning.
-     */
-    gc(max?: number): CheckpointId[];
-    private collect;
-    private moveHead;
-    private addReference;
-    private removeReference;
-    private assertBranch;
-}
-
-/**
- * Anything that can answer a Fetch `Request` with a `Response`.
- *
- * Every Mockingbird service implements this, and every runtime adapter consumes it.
- * It is the only contract shared across the whole graph.
- */
-interface FetchAPI$1 {
-    fetch(request: Request): Promise<Response>;
-}
-
-/** Options every provider constructor accepts. */
-type APIOptions = {
-    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
-    sqlite?: SqliteClient$1;
-    /** Clock used for `created`-style fields. Default `Date.now`. */
-    now?: () => number;
-    /**
-     * Storage namespace for this instance's records. Instances sharing one SQLite
-     * client stay isolated when their namespaces differ. Defaults to the service name.
-     */
-    namespace?: string;
-};
-
 /**
  * One problem with a request body, at a dotted path (`patient.address.city`, `items.0.sku`).
  * `kind` is `media_type` when the body is present but its media type is not one the operation
@@ -987,6 +1003,10 @@ type RequestLog = {
     ids?: Record<string, string>;
     /** Set when the service created a resource the request referred to but that did not exist. */
     adopted?: boolean;
+    /** Explicit durable acceptance, independent of response delivery. */
+    accepted?: boolean;
+    /** Checkpoint captured at explicit acceptance. */
+    checkpoint?: string;
     /** Set on a rejection (status ≥ 400) the mock produced itself, never on a scripted fault. */
     request?: RejectedRequest;
     /** The validation issues behind a rejection, when the service found any. */
@@ -1050,18 +1070,6 @@ type CredentialRegistry = {
     }[];
 };
 
-/**
- * Sequential id source persisted in SQLite. Ids are deterministic for a given
- * sequence history (`cus_` + 14 opaque chars), so reproductions stay stable.
- */
-declare class IdSequence {
-    private readonly sqlite;
-    private readonly namespace;
-    private readonly salt;
-    constructor(sqlite: SqliteClient$1, namespace: string, salt?: string);
-    next(prefix: string, length?: number): string;
-}
-
 /**
  * A point-in-time copy of everything a service namespace holds.
  *
@@ -1314,6 +1322,8 @@ type FlagRecord = {
     /** JSON string sent as `metadata.payload` when the flag is enabled. */
     payload: string | null;
     overrides: FlagOverride[];
+    /** Original management filters; evaluation still uses the deterministic model. */
+    filters?: Record<string, unknown>;
     version: number;
     created_at: string;
     updated_at: string;
@@ -1333,6 +1343,7 @@ type Evaluation = {
 };
 /** Body of `PUT /__admin/flags/:key`, validated. */
 type FlagSpec = {
+    filters?: Record<string, unknown>;
     name?: string;
     active?: boolean;
     default: FlagValue | null;
@@ -1384,10 +1395,24 @@ type Settings = {
     /** Session-recording posts to `/s/`, counted and discarded. */
     recordings: number;
 };
+type ExperimentRecord = {
+    id: number;
+    projectId: string;
+    name: string;
+    feature_flag_key: string;
+    parameters: Record<string, unknown>;
+    metrics: unknown[];
+    start_date: string | null;
+    end_date: string | null;
+    archived: boolean;
+    created_at: string;
+    updated_at: string;
+};
 declare class PostHogState {
     private readonly seed;
     private readonly now;
     readonly flags: Collection<FlagRecord>;
+    readonly experiments: Collection<ExperimentRecord>;
     readonly events: Collection<CapturedEvent>;
     readonly settings: Collection<Settings>;
     readonly ids: IdSequence;
@@ -1410,6 +1435,7 @@ declare class PostHogState {
 }
 
 type PostHogAPIOptions = APIOptions & {
+    adminPrefix?: string;
     /** Flags every namespace starts with (and returns to on reset), keyed by flag key. */
     flags?: Record<string, FlagSpec>;
     /** Initial per-namespace settings (session recording, canned HogQL results). */