@crvouga/mockingbird-service-formbricks 0.2.0 → 1.0.1

package/dist/index.d.ts

@@ -228,81 +228,95 @@ type FaultRegistry = {
     take(candidate: FaultCandidate): Promise<FaultHit[]>;
 };
 
-/** One handled request, as the structured log sees it. */
-type RequestLog = {
-    service: string;
-    namespace: string;
-    operationId: string | undefined;
-    method: string;
-    path: string;
-    status: number;
-    durationMs: number;
-    /** True when the path matched no operation in the contract. */
-    unmatched: boolean;
-    /** Set when a fault rule produced the response. */
-    faultId?: string;
-    /** Resource ids the handler touched (`userId`, `orderId`, …), when the service reports them. */
-    ids?: Record<string, string>;
-    /** Set when the service created a resource the request referred to but that did not exist. */
-    adopted?: boolean;
-};
-type MetricsReport = {
-    requests: number;
-    /** Counts keyed `<operationId> <status>`. */
-    byOperation: Record<string, number>;
-    /**
-     * Paths that matched no operation, most frequent first.
-     *
-     * This is the early-warning signal: a consumer calling something the mock does
-     * not implement shows up here as a count, before it fails a suite as a 404.
-     */
-    unmatched: {
-        method: string;
-        path: string;
-        count: number;
-    }[];
-    faults: number;
-    totalDurationMs: number;
-};
-type Metrics = {
-    record(entry: RequestLog): void;
-    report(): MetricsReport;
-    reset(): void;
-};
-
-/** One journal entry: a request log stamped with when (on the mock clock) it was handled. */
-type JournalEntry = RequestLog & {
-    at: 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 JournalQuery = {
-    /** Only this namespace. Omit for every namespace, oldest first across all of them. */
-    namespace?: string;
-    operationId?: string;
-    status?: number;
-    /** Only entries at or after this instant (epoch ms). */
-    since?: number;
-    /** At most this many, the most recent kept. */
-    limit?: number;
+type CommitOptions = {
+    branch?: string;
+    /** Parent checkpoint. Defaults to the selected branch's current head. */
+    parent?: CheckpointId | null;
 };
-type Journal = {
-    readonly size: number;
-    record(entry: JournalEntry): void;
-    list(query?: JournalQuery): JournalEntry[];
-    /** Forget one namespace's entries, or every namespace's. */
-    clear(namespace?: string): void;
+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;
+}
 
-/** Credential → namespace mapping behind `PUT /__admin/credentials`. */
-type CredentialRegistry = {
-    set(credential: string, namespace: string): void;
-    get(credential: string): string | undefined;
-    remove(credential: string): boolean;
-    clear(): void;
-    entries(): {
-        credential: string;
-        namespace: string;
-    }[];
-};
+/**
+ * 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 {
+    fetch(request: Request): Promise<Response>;
+}
 
 type DecodedBody = {
     kind: "empty";
@@ -521,106 +535,150 @@ type Operation = {
     responses: Record<string, ResponseObject$1>;
 };
 
-/**
- * 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. */
+/** 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;
-    /** Maximum retained checkpoints. Branch heads are never collected. Default 1,000. */
-    maxCheckpoints?: number;
-    /** Customize deterministic checkpoint IDs. */
-    id?: (sequence: number) => CheckpointId;
+    /**
+     * 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;
 };
-type CommitOptions = {
-    branch?: string;
-    /** Parent checkpoint. Defaults to the selected branch's current head. */
-    parent?: CheckpointId | null;
+type OperationContext = {
+    request: Request;
+    url: URL;
+    /** Path parameters. */
+    params: Record<string, string>;
+    /** Query string decoded with bracket notation (`created[gte]=1` -> `{ created: { gte: "1" } }`). */
+    query: FormObject;
+    body: DecodedBody;
+    /** Shared SQLite client for this service (already migrated). */
+    sqlite: SqliteClient$1;
+    /** Service namespace used for records / sequences. */
+    namespace: string;
+    operation: Operation;
+    /** The vendor contract the service was built from. */
+    document: OpenAPIDocument$1;
+    now: () => number;
 };
-type ForkOptions = {
-    /** Checkpoint to fork from. Defaults to the main branch's head. */
-    from?: CheckpointId;
+
+/**
+ * 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
+ * accepts (a `415` on most vendors), `syntax` when it could not be decoded, `required` when
+ * the operation needs a body and none arrived, and `schema` for a contract violation.
+ */
+type BodyIssue = {
+    path: string;
+    message: string;
+    kind?: "media_type" | "syntax" | "required" | "schema";
 };
+
 /**
- * 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.
+ * What the mock received from a request it rejected, so a 4xx can be attributed after the
+ * fact (an empty body, a missing `content-type`, a schema violation) without logging the body.
  */
-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;
+type RejectedRequest = {
+    /** The raw `content-type` header, or `null` when the request sent none. */
+    contentType: string | null;
+    /** Bytes of body received from `content-length` (`0` for none), or `null` when the client sent no length (a streamed / chunked body). */
+    bodyBytes: number | null;
+    /** The raw `transfer-encoding` header (`chunked`), or `null`. */
+    transferEncoding: string | null;
+};
+/** One handled request, as the structured log sees it. */
+type RequestLog = {
+    service: string;
+    namespace: string;
+    operationId: string | undefined;
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    /** True when the path matched no operation in the contract. */
+    unmatched: boolean;
+    /** Set when a fault rule produced the response. */
+    faultId?: string;
+    /** Resource ids the handler touched (`userId`, `orderId`, …), when the service reports them. */
+    ids?: Record<string, string>;
+    /** Set when the service created a resource the request referred to but that did not exist. */
+    adopted?: boolean;
+    /** 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. */
+    issues?: BodyIssue[];
+};
+type MetricsReport = {
+    requests: number;
+    /** Counts keyed `<operationId> <status>`. */
+    byOperation: Record<string, number>;
     /**
-     * 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.
+     * Paths that matched no operation, most frequent first.
+     *
+     * This is the early-warning signal: a consumer calling something the mock does
+     * not implement shows up here as a count, before it fails a suite as a 404.
      */
-    gc(max?: number): CheckpointId[];
-    private collect;
-    private moveHead;
-    private addReference;
-    private removeReference;
-    private assertBranch;
-}
+    unmatched: {
+        method: string;
+        path: string;
+        count: number;
+    }[];
+    faults: number;
+    totalDurationMs: number;
+};
+type Metrics = {
+    record(entry: RequestLog): void;
+    report(): MetricsReport;
+    reset(): void;
+};
+
+/** One journal entry: a request log stamped with when (on the mock clock) it was handled. */
+type JournalEntry = RequestLog & {
+    at: string;
+};
+type JournalQuery = {
+    /** Only this namespace. Omit for every namespace, oldest first across all of them. */
+    namespace?: string;
+    operationId?: string;
+    status?: number;
+    /** Only entries at or after this instant (epoch ms). */
+    since?: number;
+    /** At most this many, the most recent kept. */
+    limit?: number;
+};
+type Journal = {
+    readonly size: number;
+    record(entry: JournalEntry): void;
+    list(query?: JournalQuery): JournalEntry[];
+    /** Forget one namespace's entries, or every namespace's. */
+    clear(namespace?: string): void;
+};
+
+/** Credential → namespace mapping behind `PUT /__admin/credentials`. */
+type CredentialRegistry = {
+    set(credential: string, namespace: string): void;
+    get(credential: string): string | undefined;
+    remove(credential: string): boolean;
+    clear(): void;
+    entries(): {
+        credential: string;
+        namespace: string;
+    }[];
+};
 
 /**
- * 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.
+ * Sequential id source persisted in SQLite. Ids are deterministic for a given
+ * sequence history (`cus_` + 14 opaque chars), so reproductions stay stable.
  */
-interface FetchAPI {
-    fetch(request: Request): Promise<Response>;
+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;
 }
 
 /**
@@ -773,36 +831,6 @@ type ServiceRuntime<T extends ServiceInstance> = FetchAPI & {
     timeline(namespace?: string): Timeline<ServiceTimelineState>;
 };
 
-/** 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;
-};
-type OperationContext = {
-    request: Request;
-    url: URL;
-    /** Path parameters. */
-    params: Record<string, string>;
-    /** Query string decoded with bracket notation (`created[gte]=1` -> `{ created: { gte: "1" } }`). */
-    query: FormObject;
-    body: DecodedBody;
-    /** Shared SQLite client for this service (already migrated). */
-    sqlite: SqliteClient$1;
-    /** Service namespace used for records / sequences. */
-    namespace: string;
-    operation: Operation;
-    /** The vendor contract the service was built from. */
-    document: OpenAPIDocument$1;
-    now: () => number;
-};
-
 /** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
 type SqliteValue = null | number | bigint | string | Uint8Array | boolean;
 /** Mutation counters returned by {@link SqliteStatement.run}. */
@@ -832,14 +860,20 @@ interface SqliteClient {
     transaction<T>(fn: () => T): T;
 }
 
-/** A survey definition, passed through as Formbricks serves it (blocks, elements, logic, …). */
+/** A survey definition, passed through as Formbricks serves it (blocks, elements, endings, …). */
 type Survey = Record<string, unknown> & {
     id: string;
     name: string;
     type: string;
     status: string;
-    /** `null` for the shared fixture surveys, which every configured environment serves. */
-    environmentId?: string | null;
+    /** `null` for the shared corpus surveys, which every configured workspace serves. */
+    workspaceId?: string | null;
+};
+/** A contact (`PUT /__admin/contacts`); `attributes.userId` becomes the response's `contact.userId`. */
+type Contact = {
+    id: string;
+    workspaceId: string | null;
+    attributes: Record<string, string>;
 };
 /** One stored response, in Formbricks' `TResponse` shape. */
 type ResponseRecord = {
@@ -847,11 +881,11 @@ type ResponseRecord = {
     createdAt: string;
     updatedAt: string;
     surveyId: string;
-    environmentId: string;
+    workspaceId: string;
     displayId: string | null;
     contact: {
         id: string;
-        userId: string;
+        userId?: string;
     } | null;
     contactAttributes: Record<string, string> | null;
     finished: boolean;
@@ -866,34 +900,29 @@ type ResponseRecord = {
 };
 /** Per-namespace knobs, set through `PUT /__admin/settings`; cleared on reset. */
 type Settings = {
-    /** Environment ids that serve the shared fixture surveys. */
-    environments: string[];
+    /** Workspace ids that exist and serve the shared corpus surveys. */
+    workspaces: string[];
+    /** Pre-Formbricks-5 environment ids, each an alias of a workspace (`{envId: workspaceId}`). */
+    legacyEnvironmentIds: Record<string, string>;
     /** Accepted management API keys; empty means any non-empty `x-api-key` works. */
     apiKeys: string[];
     /** The `webhookId` put in webhook bodies. */
     webhookId: string;
-    /** Whether a `userId` on a response finds-or-creates a contact (the fork's behaviour). */
+    /** Contacts are an Enterprise feature: when off, a response with a `contactId` is 403. */
     contactsEnabled: boolean;
 };
-/** Our member-app production and development Formbricks environments. */
-declare const PRODUCTION_ENVIRONMENT_ID = "cmlhiza9j0009lj01my5c1g0q";
-declare const DEVELOPMENT_ENVIRONMENT_ID = "cmlhiza9c0004lj01jbuhp0nz";
+/** The default workspace every namespace starts with. */
+declare const WORKSPACE_ID = "cworkspace000000000000001";
+/** A legacy environment id that resolves to {@link WORKSPACE_ID} (older SDKs still send one). */
+declare const ENVIRONMENT_ID = "cenvironment0000000000001";
 declare const DEFAULT_SETTINGS: Settings;
-/**
- * The committed clone of our production survey definitions
- * (`packages/forms-fixtures/formbricks/prod-clone.json` in geviti-monorepo).
- */
-declare const PROD_CLONE_SURVEYS: readonly Survey[];
-declare const PROD_CLONE_EXPORTED_AT: string;
+/** The synthetic survey corpus every namespace is seeded with (`src/corpus/surveys.json`). */
+declare const CORPUS_SURVEYS: readonly Survey[];
 declare class FormbricksState {
     private readonly seed;
     readonly surveys: Collection<Survey>;
     readonly responses: Collection<ResponseRecord>;
-    readonly contacts: Collection<{
-        id: string;
-        environmentId: string;
-        userId: string;
-    }>;
+    readonly contacts: Collection<Contact>;
     readonly settings: Collection<Settings>;
     readonly ids: IdSequence;
     constructor(sqlite: SqliteClient, namespace: string, seed: {
@@ -905,17 +934,20 @@ declare class FormbricksState {
     update(patch: Partial<Settings>): Settings;
     /** Formbricks ids are cuid2: lower-case alphanumerics starting with a letter, 25 long. */
     nextId(): string;
-    knownEnvironment(environmentId: string): boolean;
+    /**
+     * `resolveClientApiIds`: a workspace id, or a legacy environment id, to its workspace id
+     * (`undefined` when neither is known).
+     */
+    resolveWorkspace(id: string): string | undefined;
+    /** The v1 `environmentId` of a workspace: its legacy environment id, else its own id. */
+    legacyEnvironmentId(workspaceId: string): string;
     allSurveys(): Survey[];
-    /** Surveys an environment serves: its own, plus the shared fixture when it is configured. */
-    surveysOf(environmentId: string): Survey[];
-    /** Whether a survey belongs to an environment (the fork's `survey.environmentId` check). */
-    belongsTo(survey: Survey, environmentId: string): boolean;
-    /** The fork's find-or-create contact for a response `userId` (the member's email). */
-    contactFor(environmentId: string, userId: string): {
-        id: string;
-        userId: string;
-    };
+    /** Surveys a workspace serves: its own, plus the shared corpus when it is configured. */
+    surveysOf(workspaceId: string): Survey[];
+    /** Whether a survey belongs to a workspace (`survey.workspaceId !== workspaceId` check). */
+    belongsTo(survey: Survey, workspaceId: string): boolean;
+    /** `getContact(contactId, workspaceId)`: a contact of that workspace (or a shared one). */
+    contactOf(contactId: string, workspaceId: string): Contact | undefined;
 }
 
 /**
@@ -1090,20 +1122,21 @@ declare const operationIds: readonly ["GetEnvironmentState", "CreateClientRespon
 declare const supportedOperationIds: readonly ["GetEnvironmentState", "CreateClientResponse", "ListResponses", "GetResponse", "ListSurveys", "CreateSurvey", "GetSurvey", "GetWidgetScript"];
 
 /**
- * The fork's response validation (`modules/api/lib/validation.ts` → `validateBlockResponses`
- * in `packages/surveys/src/lib/validation/evaluator.ts`), trimmed to what our surveys use:
- * required elements, and the implicit email / url / phone rules of openText elements. When the
- * response is finished every element is checked (including ones logic would skip); when it is
- * not, only the elements present in `data`.
+ * Formbricks' response validation (`validateResponseData` in `apps/web/modules/api/lib/validation.ts`
+ * → `validateBlockResponses` in `packages/surveys/src/lib/validation/evaluator.ts`), trimmed to the
+ * structural checks: required elements, choice membership for choice elements without an "other"
+ * option, and the implicit email / url / phone rules of openText elements. Only the elements
+ * present in `data` are checked, finished or not (upstream never checks absent elements).
+ * Custom `validation.rules` are not evaluated.
  */
 
 /** `{<elementId>: [messages]}`, or `null` when the response passes. */
-declare const validateResponseData: (survey: Survey, data: Record<string, unknown>, finished: boolean) => Record<string, string[]> | null;
+declare const validateResponseData: (survey: Survey, data: Record<string, unknown>, language?: string) => Record<string, string[]> | null;
 
-/** Where our backend receives the webhook (`onboarding-tasks.controller.ts`; `?token=` checked). */
-declare const WEBHOOK_PATH = "/onboarding-tasks/formbricks-webhook";
+/** A conventional path for the consumer app's webhook receiver (examples and the CLI help use it). */
+declare const WEBHOOK_PATH = "/webhooks/formbricks";
 /**
- * Every named Formbricks misbehaviour our consumers branch on, switched on with
+ * Every named Formbricks misbehaviour a consumer app may branch on, switched on with
  * `POST /__admin/faults {"preset": "<name>"}` (add `count` to limit it).
  */
 declare const FORMBRICKS_PRESETS: Record<string, FaultPreset>;
@@ -1120,8 +1153,8 @@ type FormbricksRuntimeOptions = {
     surveys?: readonly Survey[];
     settings?: Partial<Settings>;
     /**
-     * Where webhooks go: `url` carries our `?token=<FORMBRICKS_WEBHOOK_SECRET>`; `secret` (a
-     * `whsec_…` Standard Webhooks key) signs `webhook-signature`; `events` defaults to
+     * Where webhooks go: `url` (any query, e.g. a `?token=` your receiver checks, is kept); `secret`
+     * (a `whsec_…` Standard Webhooks key) signs `webhook-signature`; `events` defaults to
      * `["responseFinished"]` (add `"responseCreated"` for both).
      */
     webhooks?: Omit<WebhookEndpoint, "id"> & WebhookHubOptionsSubset;
@@ -1130,22 +1163,22 @@ type FormbricksRuntime = ServiceRuntime<FormbricksAPI> & {
     readonly webhooks: WebhookHub;
 };
 /**
- * The namespace carrier for the client API is the environment id in the path (the member app's
- * fetch cannot add headers); the management API's is its `x-api-key`.
+ * The namespace carrier for the client API is the workspace (or legacy environment) id in the
+ * path (the SDK cannot add headers); the management API's is its `x-api-key`.
  */
 declare const formbricksCredential: (request: Request) => string | undefined;
 /**
  * The Formbricks mock with Mockingbird's full service contract: `/health`, `/__admin/*`,
- * namespaces by header, by `/ns/<name>` prefix on `FORMBRICKS_APP_URL`, or by environment id /
- * API key (`PUT /__admin/credentials {"credentials": {"<env id or key>": "<namespace>"}}`),
+ * namespaces by header, by `/ns/<name>` prefix on the app URL, or by workspace id / API key
+ * (`PUT /__admin/credentials {"credentials": {"<workspace id or key>": "<namespace>"}}`),
  * clock control, fault presets, and Standard-Webhooks-signed `responseFinished` webhooks.
  */
 declare const createRuntime: (options?: FormbricksRuntimeOptions) => FormbricksRuntime;
 
 declare const FORMBRICKS_NAMESPACE = "formbricks";
 /** The response as the API (and the webhook) renders it: `TResponse`. */
-type ApiResponse = Omit<ResponseRecord, "environmentId">;
-/** The body Formbricks' pipeline posts to a webhook (`app/api/(internal)/pipeline/route.ts`). */
+type ApiResponse = Omit<ResponseRecord, "workspaceId">;
+/** The body Formbricks' response pipeline posts to a webhook (`process-response-pipeline-job.ts`). */
 type FormbricksWebhook = {
     webhookId: string;
     event: "responseCreated" | "responseFinished";
@@ -1160,18 +1193,21 @@ type FormbricksWebhook = {
     };
 };
 type FormbricksAPIOptions = APIOptions & {
-    /** Surveys every namespace starts with. Default: our production clone. */
+    /** Surveys every namespace starts with. Default: the synthetic corpus (`CORPUS_SURVEYS`). */
     surveys?: readonly Survey[];
     settings?: Partial<Settings>;
     /** Called for every pipeline event; the runtime signs and delivers it. */
     onWebhook?: (event: FormbricksWebhook) => void;
 };
-type ErrorCode = "not_found" | "bad_request" | "internal_server_error" | "not_authenticated" | "forbidden" | "too_many_requests";
-/** The fork's error envelope (`app/lib/api/response.ts`), with its CORS/no-store headers. */
-declare const formbricksError: (status: number, code: ErrorCode, message: string, details?: Record<string, unknown>) => Response;
+type ErrorCode = "not_found" | "bad_request" | "internal_server_error" | "unauthorized" | "not_authenticated" | "forbidden" | "too_many_requests";
+/**
+ * Formbricks' v1 error envelope (`apps/web/app/lib/api/response.ts`): `{code, message, details}`,
+ * `Cache-Control: private, no-store`, and the CORS headers on the routes that pass `cors`.
+ */
+declare const formbricksError: (status: number, code: ErrorCode, message: string, details?: Record<string, unknown>, cors?: boolean) => Response;
 /**
- * Stateful mock of Formbricks (our fork): environment state and response creation for the
- * client SDK / member app, the v1 management API, and the `responseFinished` webhook.
+ * Stateful mock of open-source Formbricks: the client environment state and response creation
+ * the JS SDK uses, the v1 management API, and the response pipeline's webhooks.
  */
 declare class FormbricksAPI implements FetchAPI$1 {
     readonly app: Hono;
@@ -1184,17 +1220,23 @@ declare class FormbricksAPI implements FetchAPI$1 {
     fetch(request: Request): Promise<Response>;
     reset(): Promise<void>;
     private iso;
-    /** A survey as the API serves it (no internal `environmentId: null`). */
-    private wireSurvey;
+    /**
+     * A survey as the v1 management API serves it: `questions` derived from `blocks`, the owning
+     * `workspaceId` and its legacy `environmentId`, and `projectOverwrites`. Shared corpus surveys
+     * are reported under the first configured workspace.
+     */
+    wireSurvey(survey: Survey): Survey;
     render(record: ResponseRecord, context?: OperationContext): ApiResponse;
     private environmentState;
     private createResponse;
-    /** Emit a pipeline event for a stored response (also used by `/__admin/responses/:id/finish`). */
+    /** Emit a pipeline event (`responseCreated` / `responseFinished`) for a stored response. */
     pipeline(event: FormbricksWebhook["event"], record: ResponseRecord, survey: Survey): void;
     private listResponses;
+    /** `getSurveys(workspaceIds, limit, offset)`: newest `updatedAt` first. */
+    private listSurveys;
     private createSurvey;
     responses(): ApiResponse[];
 }
 
-export { DEFAULT_SETTINGS, DEVELOPMENT_ENVIRONMENT_ID, FORMBRICKS_NAMESPACE, FORMBRICKS_PRESETS, FormbricksAPI, PRODUCTION_ENVIRONMENT_ID, PROD_CLONE_EXPORTED_AT, PROD_CLONE_SURVEYS, WEBHOOK_PATH, createRuntime, document, formbricksCredential, formbricksError, operationIds, supportedOperationIds, validateResponseData };
-export type { ApiResponse, FetchAPI$1 as FetchAPI, FormbricksAPIOptions, FormbricksRuntime, FormbricksRuntimeOptions, FormbricksWebhook, OperationId, ResponseRecord, Settings, SqliteClient, SupportedOperationId, Survey };
+export { CORPUS_SURVEYS, DEFAULT_SETTINGS, ENVIRONMENT_ID, FORMBRICKS_NAMESPACE, FORMBRICKS_PRESETS, FormbricksAPI, WEBHOOK_PATH, WORKSPACE_ID, createRuntime, document, formbricksCredential, formbricksError, operationIds, supportedOperationIds, validateResponseData };
+export type { ApiResponse, Contact, FetchAPI$1 as FetchAPI, FormbricksAPIOptions, FormbricksRuntime, FormbricksRuntimeOptions, FormbricksWebhook, OperationId, ResponseRecord, Settings, SqliteClient, SupportedOperationId, Survey };