@yolk-sdk/conformance 0.1.0-canary.96

package/dist/fixture.d.mts

@@ -0,0 +1,432 @@
+import { syntheticPortCredentialParams } from "./wire-internal.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/fixture.d.ts
+/** `verified` = recorded from a live service; `unverified` = synthetic placeholder. */
+declare const WireFixtureEvidence: Schema.Literals<readonly ["verified", "unverified"]>;
+type WireFixtureEvidence = typeof WireFixtureEvidence.Type;
+/** Lowercase header name to value. Request headers are allowlisted and never credentials. */
+declare const WireHeaders: Schema.$Record<Schema.String, Schema.String>;
+type WireHeaders = typeof WireHeaders.Type;
+declare const WireRequest: Schema.Struct<{
+  readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+  readonly url: Schema.NonEmptyString;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+type WireRequest = typeof WireRequest.Type;
+/**
+ * One recorded network chunk. A chunk that is valid UTF-8 on its own is stored
+ * as readable text (empty chunks as `""`); any other chunk is stored as
+ * `{ base64 }` holding its exact bytes. Replay emits exactly these bytes.
+ */
+declare const WireChunk: Schema.Union<readonly [Schema.String, Schema.Struct<{
+  readonly base64: Schema.String;
+}>]>;
+type WireChunk = typeof WireChunk.Type;
+/** A response whose whole body is valid UTF-8, stored as one string. */
+declare const WireTextBodyResponse: Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly body: Schema.String;
+  readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>;
+type WireTextBodyResponse = typeof WireTextBodyResponse.Type;
+/** A response whose whole body is not valid UTF-8 (for example a PDF), stored as base64 bytes. */
+declare const WireBase64BodyResponse: Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly bodyBase64: Schema.String;
+  readonly body: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>;
+type WireBase64BodyResponse = typeof WireBase64BodyResponse.Type;
+/** A response recorded as one whole body: exactly one of `body` or `bodyBase64`. */
+declare const WireBodyResponse: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly body: Schema.String;
+  readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly bodyBase64: Schema.String;
+  readonly body: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>]>;
+type WireBodyResponse = typeof WireBodyResponse.Type;
+/**
+ * A streamed response (for example `text/event-stream`). Each entry is one
+ * network chunk (see `WireChunk`); chunk boundaries and bytes are preserved on
+ * replay.
+ */
+declare const WireStreamResponse: Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly chunks: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly base64: Schema.String;
+  }>]>>;
+  readonly body: Schema.optionalKey<Schema.Never>;
+  readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+}>;
+type WireStreamResponse = typeof WireStreamResponse.Type;
+declare const WireResponse: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly body: Schema.String;
+  readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly bodyBase64: Schema.String;
+  readonly body: Schema.optionalKey<Schema.Never>;
+  readonly chunks: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly headers: Schema.$Record<Schema.String, Schema.String>;
+  readonly chunks: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly base64: Schema.String;
+  }>]>>;
+  readonly body: Schema.optionalKey<Schema.Never>;
+  readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+}>]>;
+type WireResponse = typeof WireResponse.Type;
+declare const WireExchange: Schema.Struct<{
+  readonly request: Schema.Struct<{
+    readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+    readonly url: Schema.NonEmptyString;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+    readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  }>;
+  readonly response: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.String;
+    readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+    readonly chunks: Schema.optionalKey<Schema.Never>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly bodyBase64: Schema.String;
+    readonly body: Schema.optionalKey<Schema.Never>;
+    readonly chunks: Schema.optionalKey<Schema.Never>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly chunks: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+      readonly base64: Schema.String;
+    }>]>>;
+    readonly body: Schema.optionalKey<Schema.Never>;
+    readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+  }>]>;
+}>;
+type WireExchange = typeof WireExchange.Type;
+declare const WireFixture: Schema.Struct<{
+  readonly id: Schema.NonEmptyString;
+  readonly caseId: Schema.NonEmptyString;
+  readonly evidence: Schema.Literals<readonly ["verified", "unverified"]>; /** Calendar date of the recording (`YYYY-MM-DD`, UTC). */
+  readonly recordedAt: Schema.String; /** Synthetic account label, for example `synthetic`; never a real account name. */
+  readonly account: Schema.NonEmptyString;
+  readonly endpoint: Schema.NonEmptyString;
+  readonly model: Schema.optionalKey<Schema.String>;
+  readonly note: Schema.optionalKey<Schema.String>;
+  readonly exchanges: Schema.NonEmptyArray<Schema.Struct<{
+    readonly request: Schema.Struct<{
+      readonly method: Schema.NonEmptyString; /** Absolute URL including any query string. */
+      readonly url: Schema.NonEmptyString;
+      readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>; /** Parsed JSON request body, or the raw text when it is not JSON (for example a form body). */
+      readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>;
+    readonly response: Schema.Union<readonly [Schema.Struct<{
+      readonly status: Schema.Int;
+      readonly headers: Schema.$Record<Schema.String, Schema.String>;
+      readonly body: Schema.String;
+      readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+      readonly chunks: Schema.optionalKey<Schema.Never>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Int;
+      readonly headers: Schema.$Record<Schema.String, Schema.String>;
+      readonly bodyBase64: Schema.String;
+      readonly body: Schema.optionalKey<Schema.Never>;
+      readonly chunks: Schema.optionalKey<Schema.Never>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Int;
+      readonly headers: Schema.$Record<Schema.String, Schema.String>;
+      readonly chunks: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly base64: Schema.String;
+      }>]>>;
+      readonly body: Schema.optionalKey<Schema.Never>;
+      readonly bodyBase64: Schema.optionalKey<Schema.Never>;
+    }>]>;
+  }>>;
+}>;
+type WireFixture = typeof WireFixture.Type;
+/** Decode unknown input (for example a JSON file) into a `WireFixture`. */
+declare const decodeWireFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly exchanges: readonly [{
+    readonly request: {
+      readonly method: string;
+      readonly url: string;
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly body?: Schema.Json | undefined;
+    };
+    readonly response: {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly body: string;
+      readonly status: number;
+      readonly bodyBase64?: undefined;
+      readonly chunks?: undefined;
+    } | {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly status: number;
+      readonly bodyBase64: string;
+      readonly body?: undefined;
+      readonly chunks?: undefined;
+    } | {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly status: number;
+      readonly chunks: readonly (string | {
+        readonly base64: string;
+      })[];
+      readonly body?: undefined;
+      readonly bodyBase64?: undefined;
+    };
+  }, ...{
+    readonly request: {
+      readonly method: string;
+      readonly url: string;
+      readonly headers?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly body?: Schema.Json | undefined;
+    };
+    readonly response: {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly body: string;
+      readonly status: number;
+      readonly bodyBase64?: undefined;
+      readonly chunks?: undefined;
+    } | {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly status: number;
+      readonly bodyBase64: string;
+      readonly body?: undefined;
+      readonly chunks?: undefined;
+    } | {
+      readonly headers: {
+        readonly [x: string]: string;
+      };
+      readonly status: number;
+      readonly chunks: readonly (string | {
+        readonly base64: string;
+      })[];
+      readonly body?: undefined;
+      readonly bodyBase64?: undefined;
+    };
+  }[]];
+  readonly id: string;
+  readonly caseId: string;
+  readonly evidence: "verified" | "unverified";
+  readonly recordedAt: string;
+  readonly account: string;
+  readonly endpoint: string;
+  readonly model?: string | undefined;
+  readonly note?: string | undefined;
+}, Schema.SchemaError, never>;
+declare const isWireStreamResponse: (response: WireResponse) => response is WireStreamResponse;
+declare const isWireBase64BodyResponse: (response: WireResponse) => response is WireBase64BodyResponse;
+/**
+ * Whole days between `recordedAt` (UTC midnight) and `now`. `NaN` when
+ * `recordedAt` is not a `YYYY-MM-DD` date.
+ */
+declare const fixtureAgeDays: (fixture: Pick<WireFixture, "recordedAt">, now: Date) => number;
+/**
+ * True when the fixture is older than `maxAgeDays` (default 30). Fixtures with
+ * an unreadable `recordedAt` are treated as stale.
+ */
+declare const isFixtureStale: (fixture: Pick<WireFixture, "recordedAt">, now: Date, maxAgeDays?: number) => boolean;
+type FixtureSecretIssueKind = 'credential_header' | 'bearer_token' | 'api_key' | 'credential_query_param' | 'credential_field';
+/** A secret-scan finding. `location` is a path into the fixture; the secret itself is never echoed. */
+type FixtureSecretIssue = {
+  readonly kind: FixtureSecretIssueKind;
+  readonly location: string;
+};
+/**
+ * Pure secret scan. Flags credential headers, bearer tokens, common API-key
+ * prefixes, JWTs, private keys, credential query/form parameters, and
+ * credential JSON fields anywhere in the fixture: metadata, URLs, headers,
+ * request bodies, response bodies (text or decodable base64), each stream
+ * chunk, and the reassembled stream (so a secret split across chunks is still
+ * found). JSON bodies and SSE `data:` payloads get the credential-field scan.
+ * Issues name locations only. Returns an empty array when clean.
+ */
+declare const scanFixtureForSecrets: (fixture: WireFixture) => ReadonlyArray<FixtureSecretIssue>;
+/**
+ * A failure a port answered instead of a value. `expected` is the port's value-level failure (for
+ * example a connector `ActionResult.failure`); `error` is the port's typed error channel. `code`
+ * is a sanitized classification, never raw provider text.
+ */
+declare const PortFailure: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["expected", "error"]>;
+  readonly code: Schema.NonEmptyString;
+  readonly message: Schema.String;
+  readonly status: Schema.optionalKey<Schema.Int>;
+}>;
+type PortFailure = typeof PortFailure.Type;
+/** A port call answered with a value (`response`, plain JSON). */
+declare const PortValueFixture: Schema.Struct<{
+  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly failure: Schema.optionalKey<Schema.Never>;
+  readonly id: Schema.NonEmptyString;
+  readonly port: Schema.NonEmptyString;
+  readonly method: Schema.NonEmptyString;
+  readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly observed: Schema.optionalKey<Schema.Struct<{
+    readonly account: Schema.NonEmptyString;
+    readonly date: Schema.String;
+  }>>;
+  readonly note: Schema.optionalKey<Schema.String>;
+}>;
+type PortValueFixture = typeof PortValueFixture.Type;
+/** A port call answered with a failure. */
+declare const PortFailureFixture: Schema.Struct<{
+  readonly failure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+  }>;
+  readonly response: Schema.optionalKey<Schema.Never>;
+  readonly id: Schema.NonEmptyString;
+  readonly port: Schema.NonEmptyString;
+  readonly method: Schema.NonEmptyString;
+  readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly observed: Schema.optionalKey<Schema.Struct<{
+    readonly account: Schema.NonEmptyString;
+    readonly date: Schema.String;
+  }>>;
+  readonly note: Schema.optionalKey<Schema.String>;
+}>;
+type PortFailureFixture = typeof PortFailureFixture.Type;
+/**
+ * One recorded call through a host-provided port: the port, the method, the credential-free JSON
+ * request, and exactly one of `response` or `failure`. Plain JSON only, so one fixture backs
+ * replay, an emulator, and parity checks alike.
+ */
+declare const PortFixture: Schema.Union<readonly [Schema.Struct<{
+  readonly response: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly failure: Schema.optionalKey<Schema.Never>;
+  readonly id: Schema.NonEmptyString;
+  readonly port: Schema.NonEmptyString;
+  readonly method: Schema.NonEmptyString;
+  readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly observed: Schema.optionalKey<Schema.Struct<{
+    readonly account: Schema.NonEmptyString;
+    readonly date: Schema.String;
+  }>>;
+  readonly note: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+  readonly failure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["expected", "error"]>;
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+    readonly status: Schema.optionalKey<Schema.Int>;
+  }>;
+  readonly response: Schema.optionalKey<Schema.Never>;
+  readonly id: Schema.NonEmptyString;
+  readonly port: Schema.NonEmptyString;
+  readonly method: Schema.NonEmptyString;
+  readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly observed: Schema.optionalKey<Schema.Struct<{
+    readonly account: Schema.NonEmptyString;
+    readonly date: Schema.String;
+  }>>;
+  readonly note: Schema.optionalKey<Schema.String>;
+}>]>;
+type PortFixture = typeof PortFixture.Type;
+/** Decode unknown input (for example a JSON file) into a `PortFixture`. */
+declare const decodePortFixture: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly method: string;
+  readonly request: Schema.Json;
+  readonly response: Schema.Json;
+  readonly id: string;
+  readonly port: string;
+  readonly note?: string | undefined;
+  readonly failure?: undefined;
+  readonly observed?: {
+    readonly account: string;
+    readonly date: string;
+  } | undefined;
+} | {
+  readonly method: string;
+  readonly request: Schema.Json;
+  readonly id: string;
+  readonly failure: {
+    readonly kind: "expected" | "error";
+    readonly code: string;
+    readonly message: string;
+    readonly status?: number | undefined;
+  };
+  readonly port: string;
+  readonly note?: string | undefined;
+  readonly response?: undefined;
+  readonly observed?: {
+    readonly account: string;
+    readonly date: string;
+  } | undefined;
+}, Schema.SchemaError, never>;
+/** Any fixture a conformance case may cite: an HTTP `WireFixture` or a `PortFixture`. */
+type ConformanceFixture = WireFixture | PortFixture;
+declare const isPortFixture: (fixture: ConformanceFixture) => fixture is PortFixture;
+declare const isPortFailureFixture: (fixture: PortFixture) => fixture is PortFailureFixture;
+/** Evidence and (when known) date of a fixture. */
+type ConformanceFixtureEvidence = {
+  readonly evidence: WireFixtureEvidence;
+  readonly date?: string;
+};
+/**
+ * Evidence and date of any fixture: a `WireFixture`'s `evidence` and `recordedAt`; a
+ * `PortFixture` is `verified` as of `observed.date` when observed, else `unverified` without a
+ * date.
+ */
+declare const conformanceFixtureEvidence: (fixture: ConformanceFixture) => ConformanceFixtureEvidence;
+/** True for a port payload key that holds a credential (`credential`, `password`, `token`, ...). */
+declare const isPortCredentialKey: (key: string) => boolean;
+/**
+ * A copy of a port payload without credential fields (see `isPortCredentialKey`: `credential(s)`
+ * plus the credential field names, AWS-style `accessKeyId` / `secretAccessKey` / `sessionToken`
+ * and their snake_case forms included), at any depth.
+ * Port requests often carry the resolved credential; record and compare requests only after this.
+ */
+declare const redactPortPayload: (value: Schema.Json) => Schema.Json;
+/**
+ * Pure secret scan of a `PortFixture`: the same token patterns and credential JSON fields as
+ * `scanFixtureForSecrets`, plus any non-null `credential` / `credentials` field (port requests must
+ * be recorded through `redactPortPayload`), plus credential query or form parameters inside every
+ * JSON string value, `note`, and `failure.message` (a signed URL a port answered, such as an S3
+ * presigned URL's `X-Amz-Signature` / `X-Amz-Credential` / `X-Amz-Security-Token`), each `name=`
+ * found and judged on its own. The only exemption: the raw value, up to `&`, `#`, whitespace, `"`,
+ * `<`, `>`, or the end (never `?` or `'`), percent-decoded, exactly equals that name's entry in
+ * `syntheticPortCredentialParams`. Parameters with escaped names (`&amp;`, percent-encoded) are not
+ * found. Covers metadata, the request, the response, and the failure. Issues name locations only.
+ * Returns an empty array when clean.
+ */
+declare const scanPortFixtureForSecrets: (fixture: PortFixture) => ReadonlyArray<FixtureSecretIssue>;
+//#endregion
+export { ConformanceFixture, ConformanceFixtureEvidence, FixtureSecretIssue, FixtureSecretIssueKind, PortFailure, PortFailureFixture, PortFixture, PortValueFixture, WireBase64BodyResponse, WireBodyResponse, WireChunk, WireExchange, WireFixture, WireFixtureEvidence, WireHeaders, WireRequest, WireResponse, WireStreamResponse, WireTextBodyResponse, conformanceFixtureEvidence, decodePortFixture, decodeWireFixture, fixtureAgeDays, isFixtureStale, isPortCredentialKey, isPortFailureFixture, isPortFixture, isWireBase64BodyResponse, isWireStreamResponse, redactPortPayload, scanFixtureForSecrets, scanPortFixtureForSecrets, syntheticPortCredentialParams };
+//# sourceMappingURL=fixture.d.mts.map

package/dist/fixture.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.mts","names":[],"sources":["../src/fixture.ts"],"mappings":"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"}