@repost/client 0.2.0 → 0.4.0

package/dist/cjs/types/transport/undici-compat.d.ts

@@ -0,0 +1,47 @@
+import { type ProxyOptions } from "./connect-proxy";
+export interface UndiciPoolOptions {
+    readonly connections: number;
+    readonly clientTtl: number;
+    readonly keepAliveTimeout: number;
+    readonly allowH2: boolean;
+    readonly connectTimeout: number;
+    readonly tls?: {
+        readonly caCertificates?: readonly string[];
+        readonly minVersion?: "TLSv1.2" | "TLSv1.3";
+        readonly maxVersion?: "TLSv1.2" | "TLSv1.3";
+        readonly ciphers?: readonly string[];
+        readonly clientCertificate?: {
+            readonly certificate: string;
+            readonly key: string;
+            readonly passphrase?: string;
+        };
+    };
+    readonly dnsResolver?: (host: string) => Promise<{
+        address: string;
+        family: 4 | 6;
+    }[]>;
+    readonly proxy?: ProxyOptions;
+}
+export interface UndiciDispatchRequest {
+    readonly path: string;
+    readonly headers: string[];
+    readonly body: Uint8Array;
+    readonly headersTimeout: number;
+    readonly bodyTimeout: number;
+    readonly signal: AbortSignal;
+    readonly onBodySent: () => void;
+    readonly maxResponseBytes: number;
+}
+export interface UndiciDispatchResponse {
+    readonly status: number;
+    readonly rawHeaders: readonly Uint8Array[];
+    readonly chunks: readonly Uint8Array[];
+    readonly compressedBytes: number;
+    readonly truncated: boolean;
+}
+export interface UndiciPool {
+    dispatch(request: UndiciDispatchRequest): Promise<UndiciDispatchResponse>;
+    close(): Promise<void>;
+}
+/** The sole Undici compatibility boundary for the SDK. */
+export declare function createUndiciPool(origin: string, options: UndiciPoolOptions): UndiciPool;

package/dist/cjs/types/transport.d.ts

@@ -1,28 +1,51 @@
 import type { Transport } from "./types";
-/** A publish rejected or failed by the Repost API. */
-export declare class RepostPublishError extends Error {
-    readonly status?: number;
-    readonly body?: unknown;
-    constructor(message: string, status?: number, body?: unknown);
-}
+export { RepostPublishError } from "./errors";
 export interface HttpTransportOptions {
-    /** Injectable fetch, for tests and custom agents. Defaults to global fetch. */
+    /** Portable fetch implementation. Defaults to `globalThis.fetch` at attempt time. */
     fetch?: typeof fetch;
-    /** Retries after the initial attempt. Default 3. */
+    /** @deprecated Runtime retries are configured with `RepostClientOptions.maxAttempts`. */
     maxRetries?: number;
-    /** Base backoff delay. Default 250ms, doubled per attempt with jitter. */
+    /** @deprecated Runtime backoff is configured with `RepostClientOptions.retryBaseDelayMs`. */
     baseDelayMs?: number;
-    /** Per-attempt timeout (each retry gets a fresh budget). Default 30s. */
+    /** @deprecated Use `RepostClientOptions.attemptTimeoutMs`. */
     timeoutMs?: number;
+    tls?: {
+        caCertificates?: readonly string[];
+        minVersion?: "TLSv1.2" | "TLSv1.3";
+        maxVersion?: "TLSv1.2" | "TLSv1.3";
+        ciphers?: readonly string[];
+        clientCertificate?: {
+            certificate: string;
+            key: string;
+            passphrase?: string;
+        };
+    };
+    proxy?: {
+        url: string;
+        credentialsProvider?: () => {
+            username: string;
+            password: string;
+        } | Promise<{
+            username: string;
+            password: string;
+        }>;
+    };
+    dnsResolver?: (host: string) => Promise<{
+        address: string;
+        family: 4 | 6;
+    }[]>;
+    http2?: boolean;
+    maxConnectionsPerOrigin?: number;
+    connectionLifetimeMs?: number;
+    connectionIdleTimeoutMs?: number;
 }
-/**
- * The HTTP transport against Repost's publish API (workstream A).
- *
- * One idempotency key is minted per send() and reused across internal
- * retries, so retrying is always safe: the server deduplicates. Retryable
- * outcomes are network errors, 5xx, 429, and 409 (a concurrent duplicate
- * still in flight); Retry-After is honored when present.
- */
+/** Portable one-attempt fetch transport. Retry and deadlines belong to the runtime. */
 export declare function createHttpTransport(options?: HttpTransportOptions): Transport;
-/** The default transport: real HTTP against the publish API. */
+/** Explicit portable transport for edge/worker runtimes. */
+export declare const createFetchTransport: typeof createHttpTransport;
+/** Selects the production Node lane; the package supports Node 20 and newer. */
+export declare function resolveDefaultTransport(options?: HttpTransportOptions): Transport;
+/** Production Node transport, loaded on first use so fetch-only bundles omit Undici. */
+export declare function createNodeTransport(options?: HttpTransportOptions): Transport;
+/** @deprecated Prefer the runtime-selected transport. */
 export declare const httpTransport: Transport;

package/dist/cjs/types/types.d.ts

@@ -1,15 +1,17 @@
 /**
  * Options for `createRepostClient` (the factory the generated client exports).
- * Construction is lazy: nothing is validated until a send.
+ * Construction snapshots and validates configuration before any send.
  */
 export interface RepostClientOptions {
     /**
      * The environment's publish API key (created with the environment in the
      * dashboard). Defaults to `process.env.REPOST_SEND_API_KEY` — the variable
-     * `repost schema init` scaffolds into `.env` — read at send time. A send
+     * `repost schema init` scaffolds into `.env` — read at construction time. A send
      * without a key throws.
      */
     apiKey?: string;
+    /** Resolve a credential once per admitted operation. Mutually exclusive with `apiKey`. */
+    apiKeyProvider?: () => string | Promise<string>;
     /**
      * @deprecated Use `apiKey` (or `REPOST_SEND_API_KEY`). Still honored when
      * `apiKey` is absent, checked before the environment variables.
@@ -17,7 +19,7 @@ export interface RepostClientOptions {
     token?: string;
     /**
      * API base URL. Defaults to `process.env.REPOST_API_URL` (the existing
-     * Repost CLI convention), read at send time.
+     * Repost CLI convention), read at construction time.
      */
     apiUrl?: string;
     /**
@@ -26,6 +28,46 @@ export interface RepostClientOptions {
      * tests.
      */
     transport?: Transport;
+    /**
+     * Injectable clock and id generators, used by the envelope timestamp and
+     * `@default(now()/uuid()/cuid())` injection. Defaults to the real ones —
+     * override for deterministic tests (the conformance suite's requirement:
+     * every runtime must expose these seams).
+     */
+    generators?: Generators;
+    attemptTimeoutMs?: number;
+    operationTimeoutMs?: number;
+    connectTimeoutMs?: number;
+    maxAttempts?: number;
+    retryBaseDelayMs?: number;
+    retryMaxDelayMs?: number;
+    maxInFlightOperations?: number;
+    maxBufferedBytes?: number;
+    /** Set to false only when sends without a caller key must fail closed. */
+    idempotencyKeyGenerator?: (() => string) | false;
+    retryEntropy?: RetryEntropy;
+    monotonicClock?: () => number;
+    wallClock?: () => number;
+    scheduler?: Scheduler;
+    observer?: import("./observer").RepostObserver;
+    telemetry?: import("./telemetry").RepostTelemetry;
+    userAgentSuffix?: string;
+    httpTransportOptions?: import("./transport").HttpTransportOptions;
+}
+export interface RetryEntropy {
+    nextInt(exclusiveBound: number): number;
+}
+export interface Scheduler {
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
+}
+/** Injectable clock and id generators (deterministic-test seam). */
+export interface Generators {
+    /** ISO-8601 timestamp source. Defaults to `new Date().toISOString()`. */
+    now?: () => string;
+    /** UUID source for `@default(uuid())`. Defaults to `crypto.randomUUID()`. */
+    uuid?: () => string;
+    /** cuid2 source for `@default(cuid())`. Defaults to `@paralleldrive/cuid2`. */
+    cuid?: () => string;
 }
 /** The Standard Webhooks envelope the runtime constructs and signs-for-send. */
 export interface Envelope {
@@ -36,20 +78,58 @@ export interface Envelope {
     /** The serialized payload (wire names, defaults injected). */
     data: Record<string, unknown>;
 }
-/** Everything a transport needs to deliver one webhook publish. */
-export interface SendRequest {
-    token: string;
-    apiUrl: string | undefined;
-    /** The receiving tenant — maps 1:1 to Svix's `app_uid` usage. */
-    customerId: string;
-    /**
-     * Caller-owned idempotency key (e.g. `order-42`): the server dedups it for
-     * 24h and rejects reuse with a different payload (422). Absent, the
-     * transport mints one per send, deduplicating internal retries only.
-     */
-    idempotencyKey?: string;
-    envelope: Envelope;
+export interface CommitTracker {
+    readonly committed: boolean;
+    markCommitted(): void;
 }
+export type BoundedHeaders = Readonly<Record<string, readonly string[]>>;
+/** Everything a one-attempt transport needs for one runtime-owned attempt. */
+export interface AttemptRequest {
+    readonly url: string;
+    readonly headers: readonly (readonly [string, string])[];
+    readonly bodyBytes: Uint8Array;
+    readonly attemptNumber: number;
+    readonly connectTimeoutMs: number;
+    readonly attemptTimeoutMs: number;
+    readonly signal: AbortSignal;
+    readonly commitTracker: CommitTracker;
+}
+export type AttemptOutcome = {
+    readonly kind: "response";
+    readonly status: number;
+    readonly headers: BoundedHeaders;
+    readonly bodyBytes: Uint8Array;
+    readonly compressedBytes: number;
+    readonly decompressedBytes: number;
+    readonly truncated: boolean;
+    readonly limitExceeded?: boolean;
+    readonly protocolError?: boolean;
+    readonly proxyError?: boolean;
+    readonly headerLimitExceeded?: boolean;
+    /** True when the transport already enforced compressed/decompressed byte and ratio limits. */
+    readonly transportLimitsApplied?: boolean;
+    readonly nonRetryable?: boolean;
+    readonly responseHeaderFields?: number;
+    readonly responseHeaderBytes?: number;
+    /** Retry-After delay sampled by the transport when response headers arrived. */
+    readonly retryAfterDelayMs?: number | null;
+    /** Release a custom response resource after the runtime has consumed it. */
+    readonly close?: () => void | Promise<void>;
+} | {
+    readonly kind: "failure";
+    readonly code: "DNS" | "CONNECT" | "PROXY" | "TLS" | "IO" | "ATTEMPT_TIMEOUT";
+    readonly reason: import("./errors").RepostFailureReason | null;
+    readonly committed: boolean;
+    /** Runtime-owned sanitization metadata for a thrown transport seam. */
+    readonly causeCategory?: import("./errors").RepostCauseCategory;
+    readonly retryable?: boolean;
+    readonly httpStatus?: number | null;
+    readonly compressedBytes?: number;
+    readonly decompressedBytes?: number;
+    readonly truncated?: boolean;
+    readonly responseHeaderFields?: number;
+    readonly responseHeaderBytes?: number;
+};
 /**
  * The result of a webhook send, as returned by Repost's publish API (202).
  */
@@ -63,12 +143,28 @@ export interface SendResult {
     /** The envelope's ISO-8601 timestamp. */
     timestamp: string;
 }
+export interface SendOperationOutcome<T = SendResult> {
+    readonly operationId: string | null;
+    readonly code: import("./errors").RepostErrorCode | "OK";
+    readonly deliveryState: import("./errors").DeliveryState;
+    readonly attemptCount: number;
+    readonly httpStatus: number | null;
+    readonly idempotencyKey: string | null;
+    readonly result: T | null;
+    readonly error: import("./errors").RepostError | null;
+}
+/** A native Promise with stable cancellation and reconciliation metadata. */
+export type SendOperation<T = SendResult> = Promise<T> & {
+    readonly outcome: Promise<SendOperationOutcome<T>>;
+    cancel(): void;
+};
 /**
  * TRANSPORT SEAM: how a send reaches Repost. The HTTP transport against the
  * publish API is the default; the no-network stub serves tests.
  */
 export interface Transport {
-    send(request: SendRequest): Promise<SendResult>;
+    send(request: AttemptRequest): Promise<AttemptOutcome>;
+    close?(): void | Promise<void>;
 }
 /**
  * An `@default` injection spec: literals are injected verbatim; `now()` emits
@@ -89,20 +185,38 @@ export type DefaultSpec = {
  * One field's serialization descriptor, as emitted into the generated client
  * by `repost generate`. Field order is payload key order.
  */
-export interface FieldDescriptor {
+export type ScalarKind = "string" | "boolean" | "int64" | "float64" | "datetime" | "json" | "enum" | "model";
+/** Descriptor-format-v2 field facts, emitted in this stable key order. */
+export interface FieldDescriptorV2 {
     /** The DSL identifier — the property name on the SDK input. */
+    schemaName: string;
+    /** The wire name after `@map` (always explicit in descriptor v2). */
+    wireName: string;
+    /** The language-neutral scalar identity used for validation. */
+    scalarKind: ScalarKind;
+    /** Referenced enum/model descriptor ID (required for those scalar kinds). */
+    descriptorId?: string;
+    /** Whether omission is an input error. */
+    requiredInInput: boolean;
+    /** Whether an explicitly present null is legal. */
+    nullableInInput: boolean;
+    /** True for list containers; elements themselves are never nullable. */
+    list: boolean;
+    /** Typed client-side default, or null when the field has none. */
+    default: DefaultSpec | null;
+}
+/** Immutable format-1 compatibility shape used only by frozen vectors. */
+export interface LegacyFieldDescriptor {
     name: string;
-    /** The `@map`'d wire name; present only when it differs from `name`. */
     wire?: string;
-    /** True for `Field[]` / `Field[]?` — elements are serialized one by one. */
     list?: boolean;
-    /** A nested payload model to recurse into, by descriptor name. */
     model?: string;
-    /** Enum member name → wire value (the possibly-`@map`'d database name). */
     enum?: Record<string, string>;
-    /** `@default` injection when the field is absent from the input. */
     default?: DefaultSpec;
 }
+export type FieldDescriptor = FieldDescriptorV2 | LegacyFieldDescriptor;
+/** Enum descriptor ID → member name → wire value. */
+export type EnumDescriptors = Record<string, Record<string, string>>;
 /** A payload model's serialization descriptor. */
 export interface ModelDescriptor {
     fields: FieldDescriptor[];
@@ -118,6 +232,15 @@ export interface EventDescriptor {
 export type WebhookDescriptors = Record<string, Record<string, EventDescriptor>>;
 /** Everything the runtime needs from the generated client. */
 export interface SchemaDescriptor {
+    /**
+     * The descriptor-format version the generated client was emitted for.
+     * `buildWebhooks` refuses a mismatch at construction. Absent only in
+     * packages generated before versioning (accepted with a warning for one
+     * release).
+     */
+    descriptorFormatVersion?: number;
+    /** Enum descriptor ID → member wire mapping. */
+    enums: EnumDescriptors;
     models: Record<string, ModelDescriptor>;
     webhooks: WebhookDescriptors;
 }

package/dist/cjs/types/version.d.ts

@@ -0,0 +1,2 @@
+/** Package version embedded in runtime identifiers and telemetry instruments. */
+export declare const PACKAGE_VERSION = "0.4.0";

package/dist/cjs/types/webhooks.d.ts

@@ -1,4 +1,13 @@
+import { type RuntimeDiagnostics } from "./runtime-state";
 import type { RepostClientOptions, SchemaDescriptor, Transport } from "./types";
+/**
+ * The descriptor-format version this runtime implements. Generated clients
+ * declare the version they were emitted for; [`buildWebhooks`] refuses a
+ * mismatch at construction — never silently at send time. Bumped only on a
+ * wire-breaking change to the descriptor contract (see
+ * sdk/conformance/CONTRACT.md and the conformance-vector freeze policy).
+ */
+export declare const DESCRIPTOR_FORMAT_VERSION = 2;
 /**
  * No-network transport for tests: echoes the envelope identity as a typed
  * `SendResult` with a fixed stub message id.
@@ -11,3 +20,9 @@ export declare const stubTransport: Transport;
  * from the same catalog.
  */
 export declare function buildWebhooks<T>(options: RepostClientOptions, schema: SchemaDescriptor): T;
+/** Build the generated webhooks tree and its credential-free diagnostics surface. */
+export declare function buildClient<T>(options: RepostClientOptions, schema: SchemaDescriptor): {
+    readonly webhooks: T;
+    diagnostics(): RuntimeDiagnostics;
+    close(): void;
+};

package/dist/cjs/version-CGqSWJir.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+/** Package version embedded in runtime identifiers and telemetry instruments. */
+const PACKAGE_VERSION = "0.4.0";
+
+exports.PACKAGE_VERSION = PACKAGE_VERSION;
+//# sourceMappingURL=version-CGqSWJir.cjs.map

package/dist/cjs/version-CGqSWJir.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-CGqSWJir.cjs","sources":["../../../src/version.ts"],"sourcesContent":["/** Package version embedded in runtime identifiers and telemetry instruments. */\nexport const PACKAGE_VERSION = \"0.4.0\";\n"],"names":[],"mappings":";;AAAA;AACO,MAAM,eAAe,GAAG;;;;"}