@crvouga/mockingbird-service-formbricks 2.1.0 → 2.3.0

package/dist/cli.js

@@ -3,8 +3,8 @@ import {
   runCli,
   serveCommand,
   serveTarget
-} from "./chunk-VBJ5ARFE.js";
-import "./chunk-KIJQHMEA.js";
+} from "./chunk-4KQ2ITDL.js";
+import "./chunk-URWHM2ZP.js";
 
 // src/cli.ts
 var code = await runCli(

package/dist/index.d.ts

@@ -10,36 +10,6 @@ interface FetchAPI$1 {
     fetch(request: Request): Promise<Response>;
 }
 
-/**
- * The single source of time for a service.
- *
- * Every timestamp a mock writes reads from here, so a suite moves time instead of
- * sleeping: appointment windows, result delays and expiries become reachable in
- * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
- */
-type ClockState = {
-    /** Current epoch milliseconds. */
-    now: number;
-    /** True while time does not advance on its own. */
-    frozen: boolean;
-    /** Milliseconds this clock adds to its underlying source. */
-    offsetMs: number;
-};
-type Clock = {
-    now(): number;
-    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
-    set(epochMs: number): void;
-    /** Move the clock forward, or back with a negative delta. */
-    advance(deltaMs: number): void;
-    /** Stop time at the current instant. */
-    freeze(): void;
-    /** Resume from the current instant. */
-    unfreeze(): void;
-    /** Drop back to the underlying source, live. */
-    reset(): void;
-    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}. */
@@ -112,144 +82,16 @@ declare class Collection<T> {
 }
 
 /**
- * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
- * request a percentage fault hits — is reproducible from a seed.
- *
- * mulberry32: small, fast, and stable across runtimes, which matters more here
- * than statistical quality.
- */
-type Rng = {
-    /** Next value in `[0, 1)`. */
-    next(): number;
-    /** Next integer in `[min, max]`. */
-    int(min: number, max: number): number;
-    /** Restart the stream from its seed. */
-    reset(): void;
-    /** Serializable engine state used by deterministic checkpoints. */
-    state(): number;
-    /** Restore a state previously returned by {@link state}. */
-    setState(state: number): void;
-    seed: number;
-};
-
-/**
- * A deliberate failure injected in front of an operation.
- *
- * This is how a suite reaches the vendor's failure modes without the vendor: the
- * quota error that only appears when a shared sandbox is full, the 429 that only
- * appears under load, the 5xx that proves a retry path works.
- */
-type FaultRule = {
-    /** Stable id, so a suite can retire exactly the rule it added. */
-    id: string;
-    /** Fault only this operation. Omit to match every operation. */
-    operationId?: string;
-    /** Fault only this HTTP method, case-insensitive. Omit to match every method. */
-    method?: string;
-    /** Fault only paths starting with this prefix. Omit to match every path. */
-    pathPrefix?: string;
-    /**
-     * Fault only this namespace. Omit (or `"*"`) to fault every namespace — which is what
-     * an in-process caller usually wants, and what a parallel worker usually does not:
-     * rules added through `POST /__admin/faults` default to the calling namespace.
-     */
-    namespace?: string;
-    /**
-     * Status of the injected response. Omit for a rule that only delays (`delayMs` /
-     * `latencyMs`), only drops the connection (`drop`), or only switches on an `effect`:
-     * the request then still reaches the service.
-     */
-    status?: number;
-    /** Response body, serialized as JSON. A string is sent as-is. */
-    body?: unknown;
-    headers?: Record<string, string>;
-    /** Retire the rule after this many faults. Omit to keep it until removed. */
-    count?: number;
-    /** Fault this fraction of matching requests, `0`–`1`. Default `1`. */
-    rate?: number;
-    /** Hold the response back this long, to exercise timeouts. */
-    delayMs?: number;
-    /** Alias of `delayMs`. */
-    latencyMs?: number;
-    /**
-     * Drop the connection instead of answering: an in-process `fetch` rejects with a
-     * `TypeError`, and a served mock destroys the socket. Models "unknown outcome" failures.
-     */
-    drop?: boolean;
-    /**
-     * A named service behaviour to switch on for the matching request instead of (or
-     * before) a canned response, e.g. `created_but_500` or `numeric_tracking_id`. Services
-     * read it with `faultEffects(request)`.
-     */
-    effect?: string;
-    /** Parameters for `effect`. */
-    params?: Record<string, unknown>;
-    /** From the preset this rule was expanded from, if any. */
-    preset?: string;
-};
-/** A fault that fired for one request. */
-type FaultHit = {
-    id: string;
-    /** The injected response; absent when the rule only delays, drops, or sets an effect. */
-    response?: Response;
-    drop?: boolean;
-    effect?: {
-        name: string;
-        params: Record<string, unknown>;
-    };
-};
-/**
- * A named, documented fault a suite switches on by name
- * (`POST /__admin/faults {"preset": "rate_limited"}`): one or more rules, and optionally a
- * webhook delivery fault.
+ * Sequential id source persisted in SQLite. Ids are deterministic for a given
+ * sequence history (`cus_` + 14 opaque chars), so reproductions stay stable.
  */
-type FaultPreset = {
-    description: string;
-    rules?: Omit<FaultRule, "id">[];
-    webhook?: {
-        mode: "duplicate" | "reorder" | "drop";
-        count?: number;
-    };
-};
-/** What a request looks like to the fault matcher. */
-type FaultCandidate = {
-    operationId: string | undefined;
-    method: string;
-    path: string;
-    namespace: string;
-};
-type FaultRegistry = {
-    isolateNamespaces(): void;
-    snapshot(namespace: string): {
-        rules: (FaultRule & {
-            remaining: number | null;
-            hits: number;
-            position: number;
-        })[];
-        rngState: number;
-    };
-    add(rule: FaultRule): FaultRule;
-    list(): (FaultRule & {
-        remaining: number | null;
-        hits: number;
-    })[];
-    remove(id: string): boolean;
-    clear(): void;
-    restore(namespace: string, state: {
-        rules: (FaultRule & {
-            remaining: number | null;
-            hits: number;
-            position: number;
-        })[];
-        rngState: number;
-    }): void;
-    /**
-     * Every fault this request should get, in rule order, stopping at the first that answers
-     * or drops (effect-only and delay-only rules let later rules match too). Consumes one of
-     * each matching rule's remaining uses.
-     */
-    take(candidate: FaultCandidate): Promise<FaultHit[]>;
-};
+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;
@@ -588,6 +430,176 @@ type OperationContext = {
     now: () => number;
 };
 
+/**
+ * The single source of time for a service.
+ *
+ * Every timestamp a mock writes reads from here, so a suite moves time instead of
+ * sleeping: appointment windows, result delays and expiries become reachable in
+ * milliseconds. A frozen clock also makes timestamps reproducible from a seed.
+ */
+type ClockState = {
+    /** Current epoch milliseconds. */
+    now: number;
+    /** True while time does not advance on its own. */
+    frozen: boolean;
+    /** Milliseconds this clock adds to its underlying source. */
+    offsetMs: number;
+};
+type Clock = {
+    now(): number;
+    /** Pin the clock to an exact instant, keeping it frozen if it already was. */
+    set(epochMs: number): void;
+    /** Move the clock forward, or back with a negative delta. */
+    advance(deltaMs: number): void;
+    /** Stop time at the current instant. */
+    freeze(): void;
+    /** Resume from the current instant. */
+    unfreeze(): void;
+    /** Drop back to the underlying source, live. */
+    reset(): void;
+    state(): ClockState;
+};
+
+/**
+ * Seeded pseudo-random numbers, so anything a mock invents — ids, jitter, which
+ * request a percentage fault hits — is reproducible from a seed.
+ *
+ * mulberry32: small, fast, and stable across runtimes, which matters more here
+ * than statistical quality.
+ */
+type Rng = {
+    /** Next value in `[0, 1)`. */
+    next(): number;
+    /** Next integer in `[min, max]`. */
+    int(min: number, max: number): number;
+    /** Restart the stream from its seed. */
+    reset(): void;
+    /** Serializable engine state used by deterministic checkpoints. */
+    state(): number;
+    /** Restore a state previously returned by {@link state}. */
+    setState(state: number): void;
+    seed: number;
+};
+
+/**
+ * A deliberate failure injected in front of an operation.
+ *
+ * This is how a suite reaches the vendor's failure modes without the vendor: the
+ * quota error that only appears when a shared sandbox is full, the 429 that only
+ * appears under load, the 5xx that proves a retry path works.
+ */
+type FaultRule = {
+    /** Stable id, so a suite can retire exactly the rule it added. */
+    id: string;
+    /** Fault only this operation. Omit to match every operation. */
+    operationId?: string;
+    /** Fault only this HTTP method, case-insensitive. Omit to match every method. */
+    method?: string;
+    /** Fault only paths starting with this prefix. Omit to match every path. */
+    pathPrefix?: string;
+    /**
+     * Fault only this namespace. Omit (or `"*"`) to fault every namespace — which is what
+     * an in-process caller usually wants, and what a parallel worker usually does not:
+     * rules added through `POST /__admin/faults` default to the calling namespace.
+     */
+    namespace?: string;
+    /**
+     * Status of the injected response. Omit for a rule that only delays (`delayMs` /
+     * `latencyMs`), only drops the connection (`drop`), or only switches on an `effect`:
+     * the request then still reaches the service.
+     */
+    status?: number;
+    /** Response body, serialized as JSON. A string is sent as-is. */
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Retire the rule after this many faults. Omit to keep it until removed. */
+    count?: number;
+    /** Fault this fraction of matching requests, `0`–`1`. Default `1`. */
+    rate?: number;
+    /** Hold the response back this long, to exercise timeouts. */
+    delayMs?: number;
+    /** Alias of `delayMs`. */
+    latencyMs?: number;
+    /**
+     * Drop the connection instead of answering: an in-process `fetch` rejects with a
+     * `TypeError`, and a served mock destroys the socket. Models "unknown outcome" failures.
+     */
+    drop?: boolean;
+    /**
+     * A named service behaviour to switch on for the matching request instead of (or
+     * before) a canned response, e.g. `created_but_500` or `numeric_tracking_id`. Services
+     * read it with `faultEffects(request)`.
+     */
+    effect?: string;
+    /** Parameters for `effect`. */
+    params?: Record<string, unknown>;
+    /** From the preset this rule was expanded from, if any. */
+    preset?: string;
+};
+/** A fault that fired for one request. */
+type FaultHit = {
+    id: string;
+    /** The injected response; absent when the rule only delays, drops, or sets an effect. */
+    response?: Response;
+    drop?: boolean;
+    effect?: {
+        name: string;
+        params: Record<string, unknown>;
+    };
+};
+/**
+ * A named, documented fault a suite switches on by name
+ * (`POST /__admin/faults {"preset": "rate_limited"}`): one or more rules, and optionally a
+ * webhook delivery fault.
+ */
+type FaultPreset = {
+    description: string;
+    rules?: Omit<FaultRule, "id">[];
+    webhook?: {
+        mode: "duplicate" | "reorder" | "drop";
+        count?: number;
+    };
+};
+/** What a request looks like to the fault matcher. */
+type FaultCandidate = {
+    operationId: string | undefined;
+    method: string;
+    path: string;
+    namespace: string;
+};
+type FaultRegistry = {
+    isolateNamespaces(): void;
+    snapshot(namespace: string): {
+        rules: (FaultRule & {
+            remaining: number | null;
+            hits: number;
+            position: number;
+        })[];
+        rngState: number;
+    };
+    add(rule: FaultRule): FaultRule;
+    list(): (FaultRule & {
+        remaining: number | null;
+        hits: number;
+    })[];
+    remove(id: string): boolean;
+    clear(): void;
+    restore(namespace: string, state: {
+        rules: (FaultRule & {
+            remaining: number | null;
+            hits: number;
+            position: number;
+        })[];
+        rngState: number;
+    }): void;
+    /**
+     * Every fault this request should get, in rule order, stopping at the first that answers
+     * or drops (effect-only and delay-only rules let later rules match too). Consumes one of
+     * each matching rule's remaining uses.
+     */
+    take(candidate: FaultCandidate): Promise<FaultHit[]>;
+};
+
 /**
  * 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
@@ -629,6 +641,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. */
@@ -692,18 +708,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.
  *

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   operationIds,
   supportedOperationIds,
   validateResponseData
-} from "./chunk-KIJQHMEA.js";
+} from "./chunk-URWHM2ZP.js";
 export {
   CORPUS_SURVEYS,
   DEFAULT_SETTINGS,