@yolk-sdk/emulators 0.1.0-canary.96

package/dist/linkedin-search/state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.mts","names":[],"sources":["../../src/linkedin-search/state.ts"],"mappings":";;;;cAwBa,+BAAA;AAAb;AAAA,cAGa,uCAAA;;;AAH+B;AAG5C;cAMa,uBAAA,GAA2B,GAAA,UAAa,MAAc;;cAItD,0BAAA,EAA0B,MAAkB;AAVL;AAAA,cAavC,+BAAA,EAA+B,MAA6C;;cAG5E,2BAAA;;cA2BA,4BAAA,EAA4B,MAAA,CAAA,MAAA;EAAA;;;;;;KAQ7B,4BAAA,UAAsC,4BAAA,CAA6B,IAAI;;;AAtCM;AAGzF;cAyCa,4BAAA,EAA4B,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;KAM7B,4BAAA,UAAsC,4BAAA,CAA6B,IAAI;;;;;cAMtE,6BAAA,EAA6B,MAAA,CAAA,MAAA;EAAA;;;;;;KAQ9B,6BAAA,UAAuC,6BAAA,CAA8B,IAAI;;cAGxE,iCAAA,EAAiC,MAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;KAWlC,2BAAA,UAAqC,iCAAA,CAAkC,IAAI;;AAxCJ;AAMnF;;cAwCa,0BAAA,EAA0B,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;KAQ3B,0BAAA,UAAoC,0BAAA,CAA2B,IAAI;;cAwIlE,yCAAA;EAAA,SAGH,GAAA;EAAA,SAAA,WAAA;AAAA;;;;;cAwFG,cAAA,GAAkB,KAAA,cAAiB,2BAA2B;;cAS9D,WAAA,GAAe,KAAA,cAAiB,2BAA2B"}

package/dist/linkedin-search/state.mjs

@@ -0,0 +1,261 @@
+import { isRecognisableBearerValue } from "../stateful-secrets.mjs";
+import { Match, Predicate, Result } from "effect";
+import * as Schema from "effect/Schema";
+import { createHash } from "node:crypto";
+//#region src/linkedin-search/state.ts
+/**
+* LinkedIn search emulator state: the Exa people searches and the Enrich Layer profiles the state
+* answers, the absent profiles, and the digests of the API keys a seed marks as rejected on each
+* origin, with the seed input and the default seed (internal; re-exported by
+* `src/linkedin-search.ts`).
+*
+* The default entities are the synthetic LinkedIn search conformance fixtures, copied as data
+* (the seeded query with the three answers the fixtures record for `numResults` 10, 3, and 2, the
+* seeded profile with its profile and email answers, and the seeded absent profile), never
+* imported from SDK code. The default rejected keys are the synthetic invalid keys the two
+* unauthorized cases send (no account data). Every rendered answer keeps the fixtures' key order.
+*
+* Rejected keys are never kept: the state holds only their per-origin digests (SHA-256 of the
+* origin, a space, and the key), so a rejected key that a request carries as its bearer reaches
+* neither the state nor `/_emulate/*`. There are no writes, cursors, minted ids, or clock reads.
+*
+* @experimental
+*/
+/** The origin every Exa fixture records; another origin is not emulated. */
+const linkedInSearchEmulatorExaOrigin = "https://api.exa.ai";
+/** The origin every Enrich Layer fixture records (its API base is `/api/v2`). */
+const linkedInSearchEmulatorEnrichLayerOrigin = "https://enrichlayer.com";
+/**
+* The per-origin digest of an API key: SHA-256 (hex) of the origin, a space, and the key. Neither
+* an origin nor a recognisable bearer holds a space, so distinct pairs never share a text.
+*/
+const linkedInSearchKeyDigest = (key, origin) => createHash("sha256").update(`${origin} ${key}`, "utf8").digest("hex");
+/** A search query as the cases seed it: trimmed, non-empty, one line, at most 500 characters. */
+const linkedInSearchQueryPattern = /^\S(?:.*\S)?$/;
+/** The profile URL form the emulator takes: `https://<host>/in/<slug>`. */
+const linkedInSearchProfileUrlPattern = /^https:\/\/[A-Za-z0-9.-]+\/in\/[^\s?#]+$/;
+/** The largest `numResults` the emulator takes. */
+const linkedInSearchMaxNumResults = 100;
+const SearchQuery = Schema.String.check(Schema.isPattern(linkedInSearchQueryPattern), Schema.isMaxLength(500));
+const ProfileUrl = Schema.String.check(Schema.isPattern(linkedInSearchProfileUrlPattern), Schema.isMaxLength(2048));
+const NumResults = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100));
+/**
+* An API key a seed marks as rejected (checked to be a recognisable fail-closed bearer value after
+* decoding, with a constant reason: a key is a credential, so no reason quotes it).
+*/
+const RejectedKey = Schema.String;
+/** A SHA-256 digest (64 lower-case hex digits). */
+const Digest = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
+/** One Exa result, in the fixtures' fields (each a string, or absent; never null). */
+const LinkedInSearchEmulatorResult = Schema.Struct({
+	title: Schema.optionalKey(Schema.String),
+	url: Schema.optionalKey(Schema.String),
+	author: Schema.optionalKey(Schema.String),
+	publishedDate: Schema.optionalKey(Schema.String),
+	text: Schema.optionalKey(Schema.String)
+});
+/**
+* An Exa people search the state answers: the query, the `numResults` it was asked with, and the
+* results answered (1 to `numResults`; no fixture records an empty search).
+*/
+const LinkedInSearchEmulatorSearch = Schema.Struct({
+	query: SearchQuery,
+	numResults: NumResults,
+	results: Schema.Array(LinkedInSearchEmulatorResult)
+});
+/**
+* An Enrich Layer profile the state answers, in the profile fixture's fields, and the email its
+* lookup answers (absent: an email lookup of this profile is not emulated).
+*/
+const LinkedInSearchEmulatorProfile = Schema.Struct({
+	url: ProfileUrl,
+	publicIdentifier: Schema.String,
+	fullName: Schema.String,
+	headline: Schema.String,
+	email: Schema.optionalKey(Schema.String)
+});
+/** The whole emulator state (JSON-compatible; what `snapshot()` returns). */
+const LinkedInSearchEmulatorStateSchema = Schema.Struct({
+	/** Digests (for the Exa origin) of the keys Exa answers with the recorded 401. */
+	exaRejectedKeyDigests: Schema.Array(Digest),
+	searches: Schema.Array(LinkedInSearchEmulatorSearch),
+	/** Digests (for the Enrich Layer origin) of the keys Enrich Layer answers with the 401. */
+	enrichLayerRejectedKeyDigests: Schema.Array(Digest),
+	profiles: Schema.Array(LinkedInSearchEmulatorProfile),
+	/** Profile URLs that name no profile: their profile lookup answers the recorded 404. */
+	absentProfileUrls: Schema.Array(ProfileUrl)
+});
+/**
+* A typed seed: every key, when given, replaces that part of the default seed (the fixture
+* entities). Rejected keys are given as keys and kept only as their per-origin digests.
+*/
+const LinkedInSearchEmulatorSeed = Schema.Struct({
+	exaRejectedKeys: Schema.optionalKey(Schema.Array(RejectedKey)),
+	searches: Schema.optionalKey(Schema.Array(LinkedInSearchEmulatorSearch)),
+	enrichLayerRejectedKeys: Schema.optionalKey(Schema.Array(RejectedKey)),
+	profiles: Schema.optionalKey(Schema.Array(LinkedInSearchEmulatorProfile)),
+	absentProfileUrls: Schema.optionalKey(Schema.Array(ProfileUrl))
+});
+const strict = { onExcessProperty: "error" };
+const decodeSeedInput = Schema.decodeUnknownResult(LinkedInSearchEmulatorSeed, strict);
+const decodeStateInput = Schema.decodeUnknownResult(LinkedInSearchEmulatorStateSchema, strict);
+/** Every field name the seed and state schemas define (the only names a seed error may print). */
+const knownFieldNames = new Set([
+	...Object.keys(LinkedInSearchEmulatorSeed.fields),
+	...Object.keys(LinkedInSearchEmulatorStateSchema.fields),
+	...Object.keys(LinkedInSearchEmulatorSearch.fields),
+	...Object.keys(LinkedInSearchEmulatorResult.fields),
+	...Object.keys(LinkedInSearchEmulatorProfile.fields)
+]);
+/**
+* A field path in constant text: array indices and the schemas' own field names as written, any
+* other key (one a seed made up, which may be anything, a key included) as `<unexpected key>`.
+*/
+const fieldPath = (path) => {
+	const text = path.map((segment) => Predicate.isNumber(segment) ? `[${segment}]` : Predicate.isString(segment) && knownFieldNames.has(segment) ? `.${segment}` : ".<unexpected key>").join("").replace(/^\./, "");
+	return text === "" ? "the seed root" : text;
+};
+/** The category of a leaf issue, in constant text. */
+const issueCategory = (tag) => {
+	switch (tag) {
+		case "MissingKey": return "missing key";
+		case "UnexpectedKey": return "unexpected key";
+		case "InvalidType": return "invalid type";
+		case "AnyOf":
+		case "OneOf": return "no matching member";
+		case "Forbidden": return "forbidden value";
+		default: return "invalid value";
+	}
+};
+/** The first leaf issue under `issue`, with its full path. */
+const firstLeaf = (issue, path) => Match.value(issue).pipe(Match.tag("Pointer", (pointer) => firstLeaf(pointer.issue, [...path, ...pointer.path])), Match.tag("Filter", (filter) => firstLeaf(filter.issue, path)), Match.tag("Encoding", (encoding) => firstLeaf(encoding.issue, path)), Match.tag("Composite", (composite) => firstLeaf(composite.issues[0], path)), Match.tag("AnyOf", (anyOf) => {
+	const [first] = anyOf.issues;
+	return first === void 0 ? {
+		issue: anyOf,
+		path
+	} : firstLeaf(first, path);
+}), Match.orElse((leaf) => ({
+	issue: leaf,
+	path
+})));
+/**
+* Why a seed does not decode, in constant text only: the category of the first issue and its
+* field path, never the input (Effect's own messages quote input values, an unexpected key's value
+* included, and a seed may carry keys). An unexpected key is reported at its parent's path.
+*/
+const issueReason = (root) => {
+	const { issue, path } = firstLeaf(root, []);
+	const where = Predicate.isTagged(issue, "UnexpectedKey") ? path.slice(0, -1) : path;
+	return `${issueCategory(issue._tag)} at ${fieldPath(where)}`;
+};
+const seededQuery = "synthetic conformance engineer";
+const person01 = {
+	title: "Synthetic Person 01 | Conformance Engineer at Example Synthetic Co",
+	url: "https://linkedin.example.com/in/synthetic-person-01",
+	author: "Synthetic Person 01",
+	text: "Synthetic Person 01. Conformance Engineer at Example Synthetic Co. Synthetic profile text, not a real person."
+};
+const person02 = {
+	title: "Synthetic Person 02 | Test Engineer at Example Synthetic Co",
+	url: "https://linkedin.example.com/in/synthetic-person-02",
+	author: "Synthetic Person 02",
+	publishedDate: "2026-01-15T00:00:00.000Z",
+	text: "Synthetic Person 02. Test Engineer at Example Synthetic Co. Synthetic profile text, not a real person."
+};
+const person03 = {
+	title: "Synthetic Person 03 | Conformance Lead at Example Synthetic Labs",
+	url: "https://linkedin.example.com/in/synthetic-person-03"
+};
+/** The limited search's second result: the fixture records it without `publishedDate`. */
+const { publishedDate: _limitedOmits, ...person02Limited } = person02;
+const defaultSearches = [
+	{
+		query: seededQuery,
+		numResults: 10,
+		results: [
+			person01,
+			person02,
+			person03
+		]
+	},
+	{
+		query: seededQuery,
+		numResults: 3,
+		results: [
+			person01,
+			person02,
+			person03
+		]
+	},
+	{
+		query: seededQuery,
+		numResults: 2,
+		results: [person01, person02Limited]
+	}
+];
+const defaultProfiles = [{
+	url: "https://linkedin.example.com/in/synthetic-person-01",
+	publicIdentifier: "synthetic-person-01",
+	fullName: "Synthetic Person 01",
+	headline: "Conformance Engineer at Example Synthetic Co",
+	email: "synthetic-person-01@example.com"
+}];
+const defaultAbsentProfileUrls = ["https://linkedin.example.com/in/synthetic-absent-person-00"];
+/** The synthetic invalid keys the unauthorized cases send (never account data). */
+const linkedInSearchEmulatorDefaultRejectedKeys = {
+	exa: ["yolk-conformance-invalid-exa-key"],
+	enrichLayer: ["yolk-conformance-invalid-enrich-layer-key"]
+};
+/** The index of the first value equal to an earlier one, or `-1`. */
+const repeatIndex = (values) => values.findIndex((value, index) => values.indexOf(value) !== index);
+/**
+* Integrity problems a decoded seed can still have, in constant text only (a category and a field
+* path, never a seeded value: a seed may carry keys anywhere).
+*/
+const seedProblem = (parts) => {
+	const search = repeatIndex(parts.searches.map((entry) => JSON.stringify([entry.query, entry.numResults])));
+	if (search !== -1) return `duplicate search at searches[${search}]`;
+	const results = parts.searches.findIndex((entry) => entry.results.length === 0 || entry.results.length > entry.numResults);
+	if (results !== -1) return `not 1 to numResults results at searches[${results}].results`;
+	const url = repeatIndex([...parts.profiles.map((profile) => profile.url), ...parts.absentProfileUrls]);
+	if (url !== -1) return url < parts.profiles.length ? `duplicate profile URL at profiles[${url}].url` : `duplicate profile URL at absentProfileUrls[${url - parts.profiles.length}]`;
+	for (const [field, keys] of [["exaRejectedKeys", parts.exaRejectedKeys], ["enrichLayerRejectedKeys", parts.enrichLayerRejectedKeys]]) {
+		const unrecognisable = keys.findIndex((key) => !isRecognisableBearerValue(key));
+		if (unrecognisable !== -1) return `not a recognisable bearer value at ${field}[${unrecognisable}]`;
+		const repeated = repeatIndex(keys);
+		if (repeated !== -1) return `duplicate key at ${field}[${repeated}]`;
+	}
+};
+const stateFromSeed = (seed) => {
+	const parts = {
+		exaRejectedKeys: seed.exaRejectedKeys ?? linkedInSearchEmulatorDefaultRejectedKeys.exa,
+		searches: seed.searches ?? defaultSearches,
+		enrichLayerRejectedKeys: seed.enrichLayerRejectedKeys ?? linkedInSearchEmulatorDefaultRejectedKeys.enrichLayer,
+		profiles: seed.profiles ?? defaultProfiles,
+		absentProfileUrls: seed.absentProfileUrls ?? defaultAbsentProfileUrls
+	};
+	return seedProblem(parts) ?? {
+		exaRejectedKeyDigests: parts.exaRejectedKeys.map((key) => linkedInSearchKeyDigest(key, "https://api.exa.ai")),
+		searches: parts.searches,
+		enrichLayerRejectedKeyDigests: parts.enrichLayerRejectedKeys.map((key) => linkedInSearchKeyDigest(key, "https://enrichlayer.com")),
+		profiles: parts.profiles,
+		absentProfileUrls: parts.absentProfileUrls
+	};
+};
+/**
+* Decode and build a seed; a string is the reason it is invalid, in constant text only (a
+* category and a field path; never an input value or a key the seed made up).
+*/
+const buildSeedState = (input) => {
+	const decoded = decodeSeedInput(input);
+	return Result.isFailure(decoded) ? issueReason(decoded.failure.issue) : stateFromSeed(decoded.success);
+};
+/** Decode a full state (a restored snapshot); a string is the reason it is invalid (constant). */
+const decodeState = (input) => {
+	const decoded = decodeStateInput(input);
+	return Result.isFailure(decoded) ? issueReason(decoded.failure.issue) : decoded.success;
+};
+//#endregion
+export { LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, LinkedInSearchEmulatorStateSchema, buildSeedState, decodeState, linkedInSearchEmulatorDefaultRejectedKeys, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorExaOrigin, linkedInSearchKeyDigest, linkedInSearchMaxNumResults, linkedInSearchProfileUrlPattern, linkedInSearchQueryPattern };
+
+//# sourceMappingURL=state.mjs.map

package/dist/linkedin-search/state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.mjs","names":[],"sources":["../../src/linkedin-search/state.ts"],"sourcesContent":["/**\n * LinkedIn search emulator state: the Exa people searches and the Enrich Layer profiles the state\n * answers, the absent profiles, and the digests of the API keys a seed marks as rejected on each\n * origin, with the seed input and the default seed (internal; re-exported by\n * `src/linkedin-search.ts`).\n *\n * The default entities are the synthetic LinkedIn search conformance fixtures, copied as data\n * (the seeded query with the three answers the fixtures record for `numResults` 10, 3, and 2, the\n * seeded profile with its profile and email answers, and the seeded absent profile), never\n * imported from SDK code. The default rejected keys are the synthetic invalid keys the two\n * unauthorized cases send (no account data). Every rendered answer keeps the fixtures' key order.\n *\n * Rejected keys are never kept: the state holds only their per-origin digests (SHA-256 of the\n * origin, a space, and the key), so a rejected key that a request carries as its bearer reaches\n * neither the state nor `/_emulate/*`. There are no writes, cursors, minted ids, or clock reads.\n *\n * @experimental\n */\nimport { createHash } from 'node:crypto'\nimport { Match, Predicate, Result, type SchemaIssue } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { isRecognisableBearerValue } from '../stateful-secrets.ts'\n\n/** The origin every Exa fixture records; another origin is not emulated. */\nexport const linkedInSearchEmulatorExaOrigin = 'https://api.exa.ai'\n\n/** The origin every Enrich Layer fixture records (its API base is `/api/v2`). */\nexport const linkedInSearchEmulatorEnrichLayerOrigin = 'https://enrichlayer.com'\n\n/**\n * The per-origin digest of an API key: SHA-256 (hex) of the origin, a space, and the key. Neither\n * an origin nor a recognisable bearer holds a space, so distinct pairs never share a text.\n */\nexport const linkedInSearchKeyDigest = (key: string, origin: string): string =>\n  createHash('sha256').update(`${origin} ${key}`, 'utf8').digest('hex')\n\n/** A search query as the cases seed it: trimmed, non-empty, one line, at most 500 characters. */\nexport const linkedInSearchQueryPattern = /^\\S(?:.*\\S)?$/\n\n/** The profile URL form the emulator takes: `https://<host>/in/<slug>`. */\nexport const linkedInSearchProfileUrlPattern = /^https:\\/\\/[A-Za-z0-9.-]+\\/in\\/[^\\s?#]+$/\n\n/** The largest `numResults` the emulator takes. */\nexport const linkedInSearchMaxNumResults = 100\n\nconst SearchQuery = Schema.String.check(\n  Schema.isPattern(linkedInSearchQueryPattern),\n  Schema.isMaxLength(500)\n)\n\nconst ProfileUrl = Schema.String.check(\n  Schema.isPattern(linkedInSearchProfileUrlPattern),\n  Schema.isMaxLength(2048)\n)\n\nconst NumResults = Schema.Int.check(\n  Schema.isGreaterThanOrEqualTo(1),\n  Schema.isLessThanOrEqualTo(linkedInSearchMaxNumResults)\n)\n\n/**\n * An API key a seed marks as rejected (checked to be a recognisable fail-closed bearer value after\n * decoding, with a constant reason: a key is a credential, so no reason quotes it).\n */\nconst RejectedKey = Schema.String\n\n/** A SHA-256 digest (64 lower-case hex digits). */\nconst Digest = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/))\n\n/** One Exa result, in the fixtures' fields (each a string, or absent; never null). */\nexport const LinkedInSearchEmulatorResult = Schema.Struct({\n  title: Schema.optionalKey(Schema.String),\n  url: Schema.optionalKey(Schema.String),\n  author: Schema.optionalKey(Schema.String),\n  publishedDate: Schema.optionalKey(Schema.String),\n  text: Schema.optionalKey(Schema.String)\n})\n\nexport type LinkedInSearchEmulatorResult = typeof LinkedInSearchEmulatorResult.Type\n\n/**\n * An Exa people search the state answers: the query, the `numResults` it was asked with, and the\n * results answered (1 to `numResults`; no fixture records an empty search).\n */\nexport const LinkedInSearchEmulatorSearch = Schema.Struct({\n  query: SearchQuery,\n  numResults: NumResults,\n  results: Schema.Array(LinkedInSearchEmulatorResult)\n})\n\nexport type LinkedInSearchEmulatorSearch = typeof LinkedInSearchEmulatorSearch.Type\n\n/**\n * An Enrich Layer profile the state answers, in the profile fixture's fields, and the email its\n * lookup answers (absent: an email lookup of this profile is not emulated).\n */\nexport const LinkedInSearchEmulatorProfile = Schema.Struct({\n  url: ProfileUrl,\n  publicIdentifier: Schema.String,\n  fullName: Schema.String,\n  headline: Schema.String,\n  email: Schema.optionalKey(Schema.String)\n})\n\nexport type LinkedInSearchEmulatorProfile = typeof LinkedInSearchEmulatorProfile.Type\n\n/** The whole emulator state (JSON-compatible; what `snapshot()` returns). */\nexport const LinkedInSearchEmulatorStateSchema = Schema.Struct({\n  /** Digests (for the Exa origin) of the keys Exa answers with the recorded 401. */\n  exaRejectedKeyDigests: Schema.Array(Digest),\n  searches: Schema.Array(LinkedInSearchEmulatorSearch),\n  /** Digests (for the Enrich Layer origin) of the keys Enrich Layer answers with the 401. */\n  enrichLayerRejectedKeyDigests: Schema.Array(Digest),\n  profiles: Schema.Array(LinkedInSearchEmulatorProfile),\n  /** Profile URLs that name no profile: their profile lookup answers the recorded 404. */\n  absentProfileUrls: Schema.Array(ProfileUrl)\n})\n\nexport type LinkedInSearchEmulatorState = typeof LinkedInSearchEmulatorStateSchema.Type\n\n/**\n * A typed seed: every key, when given, replaces that part of the default seed (the fixture\n * entities). Rejected keys are given as keys and kept only as their per-origin digests.\n */\nexport const LinkedInSearchEmulatorSeed = Schema.Struct({\n  exaRejectedKeys: Schema.optionalKey(Schema.Array(RejectedKey)),\n  searches: Schema.optionalKey(Schema.Array(LinkedInSearchEmulatorSearch)),\n  enrichLayerRejectedKeys: Schema.optionalKey(Schema.Array(RejectedKey)),\n  profiles: Schema.optionalKey(Schema.Array(LinkedInSearchEmulatorProfile)),\n  absentProfileUrls: Schema.optionalKey(Schema.Array(ProfileUrl))\n})\n\nexport type LinkedInSearchEmulatorSeed = typeof LinkedInSearchEmulatorSeed.Type\n\nconst strict = { onExcessProperty: 'error' } as const\n\nconst decodeSeedInput = Schema.decodeUnknownResult(LinkedInSearchEmulatorSeed, strict)\n\nconst decodeStateInput = Schema.decodeUnknownResult(LinkedInSearchEmulatorStateSchema, strict)\n\n/** Every field name the seed and state schemas define (the only names a seed error may print). */\nconst knownFieldNames: ReadonlySet<string> = new Set([\n  ...Object.keys(LinkedInSearchEmulatorSeed.fields),\n  ...Object.keys(LinkedInSearchEmulatorStateSchema.fields),\n  ...Object.keys(LinkedInSearchEmulatorSearch.fields),\n  ...Object.keys(LinkedInSearchEmulatorResult.fields),\n  ...Object.keys(LinkedInSearchEmulatorProfile.fields)\n])\n\n/**\n * A field path in constant text: array indices and the schemas' own field names as written, any\n * other key (one a seed made up, which may be anything, a key included) as `<unexpected key>`.\n */\nconst fieldPath = (path: ReadonlyArray<PropertyKey>): string => {\n  const text = path\n    .map(segment =>\n      Predicate.isNumber(segment)\n        ? `[${segment}]`\n        : Predicate.isString(segment) && knownFieldNames.has(segment)\n          ? `.${segment}`\n          : '.<unexpected key>'\n    )\n    .join('')\n    .replace(/^\\./, '')\n\n  return text === '' ? 'the seed root' : text\n}\n\n/** The category of a leaf issue, in constant text. */\nconst issueCategory = (tag: SchemaIssue.Issue['_tag']): string => {\n  switch (tag) {\n    case 'MissingKey':\n      return 'missing key'\n    case 'UnexpectedKey':\n      return 'unexpected key'\n    case 'InvalidType':\n      return 'invalid type'\n    case 'AnyOf':\n    case 'OneOf':\n      return 'no matching member'\n    case 'Forbidden':\n      return 'forbidden value'\n    default:\n      return 'invalid value'\n  }\n}\n\ntype Leaf = { readonly issue: SchemaIssue.Issue; readonly path: ReadonlyArray<PropertyKey> }\n\n/** The first leaf issue under `issue`, with its full path. */\nconst firstLeaf = (issue: SchemaIssue.Issue, path: ReadonlyArray<PropertyKey>): Leaf =>\n  Match.value(issue).pipe(\n    Match.tag('Pointer', pointer => firstLeaf(pointer.issue, [...path, ...pointer.path])),\n    Match.tag('Filter', filter => firstLeaf(filter.issue, path)),\n    Match.tag('Encoding', encoding => firstLeaf(encoding.issue, path)),\n    Match.tag('Composite', composite => firstLeaf(composite.issues[0], path)),\n    Match.tag('AnyOf', anyOf => {\n      const [first] = anyOf.issues\n\n      return first === undefined ? { issue: anyOf, path } : firstLeaf(first, path)\n    }),\n    Match.orElse(leaf => ({ issue: leaf, path }))\n  )\n\n/**\n * Why a seed does not decode, in constant text only: the category of the first issue and its\n * field path, never the input (Effect's own messages quote input values, an unexpected key's value\n * included, and a seed may carry keys). An unexpected key is reported at its parent's path.\n */\nconst issueReason = (root: SchemaIssue.Issue): string => {\n  const { issue, path } = firstLeaf(root, [])\n\n  // The unexpected key itself is input: report it at its parent.\n  const where = Predicate.isTagged(issue, 'UnexpectedKey') ? path.slice(0, -1) : path\n\n  return `${issueCategory(issue._tag)} at ${fieldPath(where)}`\n}\n\n// Default entities, copied from the fixtures.\n\nconst seededQuery = 'synthetic conformance engineer'\n\nconst person01: LinkedInSearchEmulatorResult = {\n  title: 'Synthetic Person 01 | Conformance Engineer at Example Synthetic Co',\n  url: 'https://linkedin.example.com/in/synthetic-person-01',\n  author: 'Synthetic Person 01',\n  text: 'Synthetic Person 01. Conformance Engineer at Example Synthetic Co. Synthetic profile text, not a real person.'\n}\n\nconst person02: LinkedInSearchEmulatorResult = {\n  title: 'Synthetic Person 02 | Test Engineer at Example Synthetic Co',\n  url: 'https://linkedin.example.com/in/synthetic-person-02',\n  author: 'Synthetic Person 02',\n  publishedDate: '2026-01-15T00:00:00.000Z',\n  text: 'Synthetic Person 02. Test Engineer at Example Synthetic Co. Synthetic profile text, not a real person.'\n}\n\nconst person03: LinkedInSearchEmulatorResult = {\n  title: 'Synthetic Person 03 | Conformance Lead at Example Synthetic Labs',\n  url: 'https://linkedin.example.com/in/synthetic-person-03'\n}\n\n/** The limited search's second result: the fixture records it without `publishedDate`. */\nconst { publishedDate: _limitedOmits, ...person02Limited } = person02\n\nconst defaultSearches: ReadonlyArray<LinkedInSearchEmulatorSearch> = [\n  // The people-results fixture (the connector's default numResults).\n  { query: seededQuery, numResults: 10, results: [person01, person02, person03] },\n  // The num-results-limit fixture: the control, then the limited search.\n  { query: seededQuery, numResults: 3, results: [person01, person02, person03] },\n  { query: seededQuery, numResults: 2, results: [person01, person02Limited] }\n]\n\nconst defaultProfiles: ReadonlyArray<LinkedInSearchEmulatorProfile> = [\n  {\n    url: 'https://linkedin.example.com/in/synthetic-person-01',\n    publicIdentifier: 'synthetic-person-01',\n    fullName: 'Synthetic Person 01',\n    headline: 'Conformance Engineer at Example Synthetic Co',\n    email: 'synthetic-person-01@example.com'\n  }\n]\n\nconst defaultAbsentProfileUrls: ReadonlyArray<string> = [\n  'https://linkedin.example.com/in/synthetic-absent-person-00'\n]\n\n/** The synthetic invalid keys the unauthorized cases send (never account data). */\nexport const linkedInSearchEmulatorDefaultRejectedKeys = {\n  exa: ['yolk-conformance-invalid-exa-key'],\n  enrichLayer: ['yolk-conformance-invalid-enrich-layer-key']\n} as const\n\ntype SeedParts = {\n  readonly exaRejectedKeys: ReadonlyArray<string>\n  readonly searches: ReadonlyArray<LinkedInSearchEmulatorSearch>\n  readonly enrichLayerRejectedKeys: ReadonlyArray<string>\n  readonly profiles: ReadonlyArray<LinkedInSearchEmulatorProfile>\n  readonly absentProfileUrls: ReadonlyArray<string>\n}\n\n/** The index of the first value equal to an earlier one, or `-1`. */\nconst repeatIndex = <A>(values: ReadonlyArray<A>): number =>\n  values.findIndex((value, index) => values.indexOf(value) !== index)\n\n/**\n * Integrity problems a decoded seed can still have, in constant text only (a category and a field\n * path, never a seeded value: a seed may carry keys anywhere).\n */\nconst seedProblem = (parts: SeedParts): string | undefined => {\n  const search = repeatIndex(\n    parts.searches.map(entry => JSON.stringify([entry.query, entry.numResults]))\n  )\n\n  if (search !== -1) return `duplicate search at searches[${search}]`\n\n  // No fixture records an empty search, and Exa answers at most numResults results.\n  const results = parts.searches.findIndex(\n    entry => entry.results.length === 0 || entry.results.length > entry.numResults\n  )\n\n  if (results !== -1) return `not 1 to numResults results at searches[${results}].results`\n\n  const urls = [...parts.profiles.map(profile => profile.url), ...parts.absentProfileUrls]\n  const url = repeatIndex(urls)\n\n  if (url !== -1) {\n    return url < parts.profiles.length\n      ? `duplicate profile URL at profiles[${url}].url`\n      : `duplicate profile URL at absentProfileUrls[${url - parts.profiles.length}]`\n  }\n\n  for (const [field, keys] of [\n    ['exaRejectedKeys', parts.exaRejectedKeys],\n    ['enrichLayerRejectedKeys', parts.enrichLayerRejectedKeys]\n  ] as const) {\n    const unrecognisable = keys.findIndex(key => !isRecognisableBearerValue(key))\n\n    if (unrecognisable !== -1) {\n      return `not a recognisable bearer value at ${field}[${unrecognisable}]`\n    }\n\n    const repeated = repeatIndex(keys)\n\n    if (repeated !== -1) return `duplicate key at ${field}[${repeated}]`\n  }\n\n  return undefined\n}\n\nconst stateFromSeed = (seed: LinkedInSearchEmulatorSeed): LinkedInSearchEmulatorState | string => {\n  const parts: SeedParts = {\n    exaRejectedKeys: seed.exaRejectedKeys ?? linkedInSearchEmulatorDefaultRejectedKeys.exa,\n    searches: seed.searches ?? defaultSearches,\n    enrichLayerRejectedKeys:\n      seed.enrichLayerRejectedKeys ?? linkedInSearchEmulatorDefaultRejectedKeys.enrichLayer,\n    profiles: seed.profiles ?? defaultProfiles,\n    absentProfileUrls: seed.absentProfileUrls ?? defaultAbsentProfileUrls\n  }\n\n  return (\n    seedProblem(parts) ?? {\n      exaRejectedKeyDigests: parts.exaRejectedKeys.map(key =>\n        linkedInSearchKeyDigest(key, linkedInSearchEmulatorExaOrigin)\n      ),\n      searches: parts.searches,\n      enrichLayerRejectedKeyDigests: parts.enrichLayerRejectedKeys.map(key =>\n        linkedInSearchKeyDigest(key, linkedInSearchEmulatorEnrichLayerOrigin)\n      ),\n      profiles: parts.profiles,\n      absentProfileUrls: parts.absentProfileUrls\n    }\n  )\n}\n\n/**\n * Decode and build a seed; a string is the reason it is invalid, in constant text only (a\n * category and a field path; never an input value or a key the seed made up).\n */\nexport const buildSeedState = (input: unknown): LinkedInSearchEmulatorState | string => {\n  const decoded = decodeSeedInput(input)\n\n  return Result.isFailure(decoded)\n    ? issueReason(decoded.failure.issue)\n    : stateFromSeed(decoded.success)\n}\n\n/** Decode a full state (a restored snapshot); a string is the reason it is invalid (constant). */\nexport const decodeState = (input: unknown): LinkedInSearchEmulatorState | string => {\n  const decoded = decodeStateInput(input)\n\n  return Result.isFailure(decoded) ? issueReason(decoded.failure.issue) : decoded.success\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,kCAAkC;;AAG/C,MAAa,0CAA0C;;;;;AAMvD,MAAa,2BAA2B,KAAa,WACnD,WAAW,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,MAAM,EAAE,OAAO,KAAK;;AAGtE,MAAa,6BAA6B;;AAG1C,MAAa,kCAAkC;;AAG/C,MAAa,8BAA8B;AAE3C,MAAM,cAAc,OAAO,OAAO,MAChC,OAAO,UAAU,0BAA0B,GAC3C,OAAO,YAAY,GAAG,CACxB;AAEA,MAAM,aAAa,OAAO,OAAO,MAC/B,OAAO,UAAU,+BAA+B,GAChD,OAAO,YAAY,IAAI,CACzB;AAEA,MAAM,aAAa,OAAO,IAAI,MAC5B,OAAO,uBAAuB,CAAC,GAC/B,OAAO,oBAAA,GAA+C,CACxD;;;;;AAMA,MAAM,cAAc,OAAO;;AAG3B,MAAM,SAAS,OAAO,OAAO,MAAM,OAAO,UAAU,gBAAgB,CAAC;;AAGrE,MAAa,+BAA+B,OAAO,OAAO;CACxD,OAAO,OAAO,YAAY,OAAO,MAAM;CACvC,KAAK,OAAO,YAAY,OAAO,MAAM;CACrC,QAAQ,OAAO,YAAY,OAAO,MAAM;CACxC,eAAe,OAAO,YAAY,OAAO,MAAM;CAC/C,MAAM,OAAO,YAAY,OAAO,MAAM;AACxC,CAAC;;;;;AAQD,MAAa,+BAA+B,OAAO,OAAO;CACxD,OAAO;CACP,YAAY;CACZ,SAAS,OAAO,MAAM,4BAA4B;AACpD,CAAC;;;;;AAQD,MAAa,gCAAgC,OAAO,OAAO;CACzD,KAAK;CACL,kBAAkB,OAAO;CACzB,UAAU,OAAO;CACjB,UAAU,OAAO;CACjB,OAAO,OAAO,YAAY,OAAO,MAAM;AACzC,CAAC;;AAKD,MAAa,oCAAoC,OAAO,OAAO;;CAE7D,uBAAuB,OAAO,MAAM,MAAM;CAC1C,UAAU,OAAO,MAAM,4BAA4B;;CAEnD,+BAA+B,OAAO,MAAM,MAAM;CAClD,UAAU,OAAO,MAAM,6BAA6B;;CAEpD,mBAAmB,OAAO,MAAM,UAAU;AAC5C,CAAC;;;;;AAQD,MAAa,6BAA6B,OAAO,OAAO;CACtD,iBAAiB,OAAO,YAAY,OAAO,MAAM,WAAW,CAAC;CAC7D,UAAU,OAAO,YAAY,OAAO,MAAM,4BAA4B,CAAC;CACvE,yBAAyB,OAAO,YAAY,OAAO,MAAM,WAAW,CAAC;CACrE,UAAU,OAAO,YAAY,OAAO,MAAM,6BAA6B,CAAC;CACxE,mBAAmB,OAAO,YAAY,OAAO,MAAM,UAAU,CAAC;AAChE,CAAC;AAID,MAAM,SAAS,EAAE,kBAAkB,QAAQ;AAE3C,MAAM,kBAAkB,OAAO,oBAAoB,4BAA4B,MAAM;AAErF,MAAM,mBAAmB,OAAO,oBAAoB,mCAAmC,MAAM;;AAG7F,MAAM,kBAAuC,IAAI,IAAI;CACnD,GAAG,OAAO,KAAK,2BAA2B,MAAM;CAChD,GAAG,OAAO,KAAK,kCAAkC,MAAM;CACvD,GAAG,OAAO,KAAK,6BAA6B,MAAM;CAClD,GAAG,OAAO,KAAK,6BAA6B,MAAM;CAClD,GAAG,OAAO,KAAK,8BAA8B,MAAM;AACrD,CAAC;;;;;AAMD,MAAM,aAAa,SAA6C;CAC9D,MAAM,OAAO,KACV,KAAI,YACH,UAAU,SAAS,OAAO,IACtB,IAAI,QAAQ,KACZ,UAAU,SAAS,OAAO,KAAK,gBAAgB,IAAI,OAAO,IACxD,IAAI,YACJ,mBACR,EACC,KAAK,EAAE,EACP,QAAQ,OAAO,EAAE;CAEpB,OAAO,SAAS,KAAK,kBAAkB;AACzC;;AAGA,MAAM,iBAAiB,QAA2C;CAChE,QAAQ,KAAR;EACE,KAAK,cACH,OAAO;EACT,KAAK,iBACH,OAAO;EACT,KAAK,eACH,OAAO;EACT,KAAK;EACL,KAAK,SACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;AAKA,MAAM,aAAa,OAA0B,SAC3C,MAAM,MAAM,KAAK,EAAE,KACjB,MAAM,IAAI,YAAW,YAAW,UAAU,QAAQ,OAAO,CAAC,GAAG,MAAM,GAAG,QAAQ,IAAI,CAAC,CAAC,GACpF,MAAM,IAAI,WAAU,WAAU,UAAU,OAAO,OAAO,IAAI,CAAC,GAC3D,MAAM,IAAI,aAAY,aAAY,UAAU,SAAS,OAAO,IAAI,CAAC,GACjE,MAAM,IAAI,cAAa,cAAa,UAAU,UAAU,OAAO,IAAI,IAAI,CAAC,GACxE,MAAM,IAAI,UAAS,UAAS;CAC1B,MAAM,CAAC,SAAS,MAAM;CAEtB,OAAO,UAAU,KAAA,IAAY;EAAE,OAAO;EAAO;CAAK,IAAI,UAAU,OAAO,IAAI;AAC7E,CAAC,GACD,MAAM,QAAO,UAAS;CAAE,OAAO;CAAM;AAAK,EAAE,CAC9C;;;;;;AAOF,MAAM,eAAe,SAAoC;CACvD,MAAM,EAAE,OAAO,SAAS,UAAU,MAAM,CAAC,CAAC;CAG1C,MAAM,QAAQ,UAAU,SAAS,OAAO,eAAe,IAAI,KAAK,MAAM,GAAG,EAAE,IAAI;CAE/E,OAAO,GAAG,cAAc,MAAM,IAAI,EAAE,MAAM,UAAU,KAAK;AAC3D;AAIA,MAAM,cAAc;AAEpB,MAAM,WAAyC;CAC7C,OAAO;CACP,KAAK;CACL,QAAQ;CACR,MAAM;AACR;AAEA,MAAM,WAAyC;CAC7C,OAAO;CACP,KAAK;CACL,QAAQ;CACR,eAAe;CACf,MAAM;AACR;AAEA,MAAM,WAAyC;CAC7C,OAAO;CACP,KAAK;AACP;;AAGA,MAAM,EAAE,eAAe,eAAe,GAAG,oBAAoB;AAE7D,MAAM,kBAA+D;CAEnE;EAAE,OAAO;EAAa,YAAY;EAAI,SAAS;GAAC;GAAU;GAAU;EAAQ;CAAE;CAE9E;EAAE,OAAO;EAAa,YAAY;EAAG,SAAS;GAAC;GAAU;GAAU;EAAQ;CAAE;CAC7E;EAAE,OAAO;EAAa,YAAY;EAAG,SAAS,CAAC,UAAU,eAAe;CAAE;AAC5E;AAEA,MAAM,kBAAgE,CACpE;CACE,KAAK;CACL,kBAAkB;CAClB,UAAU;CACV,UAAU;CACV,OAAO;AACT,CACF;AAEA,MAAM,2BAAkD,CACtD,4DACF;;AAGA,MAAa,4CAA4C;CACvD,KAAK,CAAC,kCAAkC;CACxC,aAAa,CAAC,2CAA2C;AAC3D;;AAWA,MAAM,eAAkB,WACtB,OAAO,WAAW,OAAO,UAAU,OAAO,QAAQ,KAAK,MAAM,KAAK;;;;;AAMpE,MAAM,eAAe,UAAyC;CAC5D,MAAM,SAAS,YACb,MAAM,SAAS,KAAI,UAAS,KAAK,UAAU,CAAC,MAAM,OAAO,MAAM,UAAU,CAAC,CAAC,CAC7E;CAEA,IAAI,WAAW,IAAI,OAAO,gCAAgC,OAAO;CAGjE,MAAM,UAAU,MAAM,SAAS,WAC7B,UAAS,MAAM,QAAQ,WAAW,KAAK,MAAM,QAAQ,SAAS,MAAM,UACtE;CAEA,IAAI,YAAY,IAAI,OAAO,2CAA2C,QAAQ;CAG9E,MAAM,MAAM,YAAY,CADV,GAAG,MAAM,SAAS,KAAI,YAAW,QAAQ,GAAG,GAAG,GAAG,MAAM,iBAC3C,CAAC;CAE5B,IAAI,QAAQ,IACV,OAAO,MAAM,MAAM,SAAS,SACxB,qCAAqC,IAAI,SACzC,8CAA8C,MAAM,MAAM,SAAS,OAAO;CAGhF,KAAK,MAAM,CAAC,OAAO,SAAS,CAC1B,CAAC,mBAAmB,MAAM,eAAe,GACzC,CAAC,2BAA2B,MAAM,uBAAuB,CAC3D,GAAY;EACV,MAAM,iBAAiB,KAAK,WAAU,QAAO,CAAC,0BAA0B,GAAG,CAAC;EAE5E,IAAI,mBAAmB,IACrB,OAAO,sCAAsC,MAAM,GAAG,eAAe;EAGvE,MAAM,WAAW,YAAY,IAAI;EAEjC,IAAI,aAAa,IAAI,OAAO,oBAAoB,MAAM,GAAG,SAAS;CACpE;AAGF;AAEA,MAAM,iBAAiB,SAA2E;CAChG,MAAM,QAAmB;EACvB,iBAAiB,KAAK,mBAAmB,0CAA0C;EACnF,UAAU,KAAK,YAAY;EAC3B,yBACE,KAAK,2BAA2B,0CAA0C;EAC5E,UAAU,KAAK,YAAY;EAC3B,mBAAmB,KAAK,qBAAqB;CAC/C;CAEA,OACE,YAAY,KAAK,KAAK;EACpB,uBAAuB,MAAM,gBAAgB,KAAI,QAC/C,wBAAwB,KAAA,oBAAoC,CAC9D;EACA,UAAU,MAAM;EAChB,+BAA+B,MAAM,wBAAwB,KAAI,QAC/D,wBAAwB,KAAA,yBAA4C,CACtE;EACA,UAAU,MAAM;EAChB,mBAAmB,MAAM;CAC3B;AAEJ;;;;;AAMA,MAAa,kBAAkB,UAAyD;CACtF,MAAM,UAAU,gBAAgB,KAAK;CAErC,OAAO,OAAO,UAAU,OAAO,IAC3B,YAAY,QAAQ,QAAQ,KAAK,IACjC,cAAc,QAAQ,OAAO;AACnC;;AAGA,MAAa,eAAe,UAAyD;CACnF,MAAM,UAAU,iBAAiB,KAAK;CAEtC,OAAO,OAAO,UAAU,OAAO,IAAI,YAAY,QAAQ,QAAQ,KAAK,IAAI,QAAQ;AAClF"}

package/dist/linkedin-search.d.mts

@@ -0,0 +1,69 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulCoverage, StatefulEmulatorApi, StatefulFault, StatefulFaultMatch, StatefulFaultState, StatefulInputKind, StatefulLedgerEntry } from "./stateful-emulator.mjs";
+import { LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, LinkedInSearchEmulatorState, LinkedInSearchEmulatorStateSchema, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorExaOrigin } from "./linkedin-search/state.mjs";
+import { LinkedInSearchEmulatorDrills, linkedInSearchEmulatorErrorBodies } from "./linkedin-search/api.mjs";
+
+//#region src/linkedin-search.d.ts
+/**
+ * Route evidence manifest: every emulated route (all reads) and the conformance cases whose
+ * (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers by
+ * construction (both come from one route table).
+ */
+declare const linkedInSearchEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/**
+ * Optional fault filter; an omitted field matches every request. `method` is the HTTP method;
+ * `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the
+ * manifest (another value is rejected when the fault is added).
+ */
+declare const LinkedInSearchFaultMatch: import("effect/Schema").Struct<{
+  readonly method: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  readonly path: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  readonly route: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+}>;
+type LinkedInSearchFaultMatch = typeof StatefulFaultMatch.Type;
+/**
+ * A status fault (400-599): answer matching requests with this status, headers, and body instead
+ * of the route's answer. The body defaults to `{ error: { type: 'emulator_fault', message } }`;
+ * `count` limits how many requests it answers. Only a request the emulator would answer reaches a
+ * fault: a request that is not emulated, by its shape or by the state, never uses one up.
+ */
+declare const LinkedInSearchFault: import("effect/Schema").Struct<{
+  readonly kind: import("effect/Schema").Literal<"status">;
+  readonly status: import("effect/Schema").Int;
+  readonly headers: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+  readonly body: import("effect/Schema").optionalKey<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+  readonly match: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+    readonly method: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    readonly path: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    readonly route: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  }>>;
+  readonly count: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+}>;
+type LinkedInSearchFault = StatefulFault;
+type LinkedInSearchFaultState = StatefulFaultState;
+type LinkedInSearchLedgerEntry = StatefulLedgerEntry;
+type LinkedInSearchCoverage = StatefulCoverage;
+declare const LinkedInSearchEmulatorInputInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "LinkedInSearchEmulatorInputInvalid";
+} & Readonly<A>;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+declare class LinkedInSearchEmulatorInputInvalid extends LinkedInSearchEmulatorInputInvalid_base<{
+  readonly input: StatefulInputKind;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type LinkedInSearchEmulatorOptions = {
+  /** Typed seed; defaults to the fixture entities. */readonly seed?: LinkedInSearchEmulatorSeed; /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */
+  readonly drills?: LinkedInSearchEmulatorDrills;
+};
+type LinkedInSearchEmulator = StatefulEmulatorApi<LinkedInSearchEmulatorState, LinkedInSearchEmulatorSeed>;
+/**
+ * Create a stateful LinkedIn search emulator on the `@emulators/core` custom runtime. Each call
+ * has its own state, ledger, and faults. Rejects with `LinkedInSearchEmulatorInputInvalid` for an
+ * invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.
+ */
+declare const makeLinkedInSearchEmulator: (options?: LinkedInSearchEmulatorOptions) => Promise<LinkedInSearchEmulator>;
+//#endregion
+export { type EmulatorEvidence, type EmulatorRouteEvidence, LinkedInSearchCoverage, LinkedInSearchEmulator, type LinkedInSearchEmulatorDrills, LinkedInSearchEmulatorInputInvalid, LinkedInSearchEmulatorOptions, LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, type LinkedInSearchEmulatorState, LinkedInSearchEmulatorStateSchema, LinkedInSearchFault, LinkedInSearchFaultMatch, LinkedInSearchFaultState, LinkedInSearchLedgerEntry, emulatorEvidenceHeader, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorErrorBodies, linkedInSearchEmulatorExaOrigin, linkedInSearchEmulatorRoutes, makeLinkedInSearchEmulator };
+//# sourceMappingURL=linkedin-search.d.mts.map

package/dist/linkedin-search.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkedin-search.d.mts","names":[],"sources":["../src/linkedin-search.ts"],"mappings":";;;;;;;;AAuH8E;AAQ9E;;cARa,4BAAA,EAA8B,aAAa,CAAC,qBAAA;;;;;;cAQ5C,wBAAA,0BAAwB,MAAA;EAAA;;;;KAEzB,wBAAA,UAAkC,kBAAA,CAAmB,IAAI;;;AAArE;;;;cAQa,mBAAA,0BAAmB,MAAA;EAAA;;;;;;;;;;;KAEpB,mBAAA,GAAsB,aAAa;AAAA,KAEnC,wBAAA,GAA2B,kBAAkB;AAAA,KAE7C,yBAAA,GAA4B,mBAAmB;AAAA,KAE/C,sBAAA,GAAyB,gBAAgB;AAAA,cAAA,uCAAA;;;;cAGxC,kCAAA,SAA2C,uCAAA;EAAA,SAG7C,KAAA,EAAO,iBAAA;EAAA,SACP,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,6BAAA;+DAED,IAAA,GAAO,0BAAA;WAEP,MAAA,GAAS,4BAA4B;AAAA;AAAA,KAGpC,sBAAA,GAAyB,mBAAA,CACnC,2BAAA,EACA,0BAAA;;;;;AA7BF;cA8Ca,0BAAA,GACX,OAAA,GAAS,6BAAA,KACR,OAAA,CAAQ,sBAAA"}

package/dist/linkedin-search.mjs

@@ -0,0 +1,158 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, checkBooleanDrills, makeStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, LinkedInSearchEmulatorStateSchema, buildSeedState, decodeState, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorExaOrigin, linkedInSearchKeyDigest } from "./linkedin-search/state.mjs";
+import { linkedInSearchApiRoutes, linkedInSearchEmulatorDrillKnobs, linkedInSearchEmulatorErrorBodies } from "./linkedin-search/api.mjs";
+import { Data, Predicate } from "effect";
+//#region src/linkedin-search.ts
+/**
+* Stateful LinkedIn search emulator (the Exa and Enrich Layer routes of the LinkedIn search
+* conformance cases: `POST /search` on `https://api.exa.ai`, and `GET /api/v2/profile` and
+* `GET /api/v2/profile/email` on `https://enrichlayer.com`), built on the upstream
+* `@emulators/core` custom runtime, with a request ledger, status faults, and an `/_emulate/*`
+* control plane.
+*
+* It never imports SDK code: its answers, error bodies, and default seed are copied as data from
+* the synthetic LinkedIn search conformance fixtures, and every route names the conformance cases
+* it follows in `linkedInSearchEmulatorRoutes`. Only the routes those seven cases send are
+* emulated, and every one is a read (nothing is ever written). Response behaviour comes only from
+* the fixtures, byte for byte: a search answers only the results the state holds for exactly its
+* query and `numResults` (the default seed holds the three the fixtures record, for `numResults`
+* 10, 3, and 2); a profile lookup answers a held profile, or the recorded 404 for a seeded absent
+* profile; an email lookup answers a held profile's recorded email. A key a seed marks as rejected
+* on an origin answers that origin's recorded 401 (the default seed rejects the synthetic invalid
+* keys the two unauthorized cases send). Anything else answers one ledgered 400 not-emulated and
+* uses up no fault. Every route answers only on its recorded origin (`fetchOn(origin)` serves one
+* behind a loopback rewrite).
+*
+* Fail closed, on the shared wrapper's fail-closed mode exactly as `/github` and `/google` use it:
+* a request is recognised only when its raw path is exactly an emulated route path under that
+* route's method, and any `Authorization` header is exactly `Bearer <token>` with a recognisable
+* bearer (the RFC 6750 `b64token` syntax, at least 8 characters, a first character in
+* `[G-Zg-z\-._~+/]` other than `n`, `r`, `t`, `u`, and a character outside `[0-9.eE+-]`). Every
+* other request is ledgered and answered with constant text only (`/<unrecognised>`, a standard
+* method or `<other>`, an empty query, no body, a constant reason). A recognised request that
+* repeats the bearer anywhere (its raw path, the raw query or any query key or value, the recorded
+* `content-type` header, or its body, through the wrapper's fixpoint closure of tolerant
+* percent-decoding and JSON-unescaping, capped, where a cap refuses) is ledgered with constant text
+* only; any other has the bearer scrubbed from every ledgered field and reason. The bearer is never
+* stored, forwarded, or ledgered: routes see only its per-origin digest (the wrapper's opt-in
+* `bearerDigest`; SHA-256 of the origin, a space, and the key), which a plan compares with the
+* digests of the seed's rejected keys for that origin; the state holds only those digests, so a key
+* a request carries as its bearer, a rejected one included, never reaches the state or
+* `/_emulate/*` (a key sent as data elsewhere in a request is ledgered like any other text), and
+* seed errors are constant text (a category and a field path) that never quote one. Refusals never
+* echo a request's own query or body keys (the wrapper's constant-reason `exactQuery` and
+* `exactBodyKeys`).
+*
+* Request-shape latitude (`/linkedin-search`, the only accepted deviations): any bearer value in
+* the RFC 6750 `b64token` syntax (`[A-Za-z0-9\-._~+/]+=*`) of at least 8 characters, starting with
+* a character in `[G-Zg-z\-._~+/]` other than `n`, `r`, `t`, `u`, with at least one outside
+* `[0-9.eE+-]`, that occurs nowhere else in the request (never stored or ledgered; only its
+* per-origin digest is compared, with the digests of the keys the seed marks as rejected on that
+* origin); extra request headers; JSON key order; `content-type` media-type parameters on the
+* search; any percent-encoding of the `linkedin_profile_url` value that decodes once to the same
+* profile URL; and, with a key the seed marks as rejected on the request's origin, any search
+* `query` (one trimmed line of at most 500 characters) with any integer `numResults` from 1 to 100,
+* and any profile URL of the form `https://<host>/in/<slug>`, each answered the origin's
+* recorded 401. `Authorization` must be exactly `Bearer <token>` (that spelling, one space).
+* Everything else (other body keys or values, a `category` other than `people`, a `type` other than
+* `auto`, `contents` other than `{ "text": true }`, a search the state holds no answer for (another
+* query, or a `numResults` no seeded search of that query records), a profile URL the state holds
+* neither as a profile nor as absent, an email lookup of an absent profile, any query parameter on
+* the search, other, missing, or repeated query parameters on a lookup, a query parameter name in
+* any but its plain form (such as `%6cinkedin_profile_url`), empty query components such as a bare
+* `?` or a stray `&`, a body on a lookup, another origin, and a bearer repeated anywhere in the
+* request) is not emulated.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeLinkedInSearchEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+/**
+* Route evidence manifest: every emulated route (all reads) and the conformance cases whose
+* (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers by
+* construction (both come from one route table).
+*/
+const linkedInSearchEmulatorRoutes = linkedInSearchApiRoutes.map(routeEvidence);
+/**
+* Optional fault filter; an omitted field matches every request. `method` is the HTTP method;
+* `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the
+* manifest (another value is rejected when the fault is added).
+*/
+const LinkedInSearchFaultMatch = StatefulFaultMatch;
+/**
+* A status fault (400-599): answer matching requests with this status, headers, and body instead
+* of the route's answer. The body defaults to `{ error: { type: 'emulator_fault', message } }`;
+* `count` limits how many requests it answers. Only a request the emulator would answer reaches a
+* fault: a request that is not emulated, by its shape or by the state, never uses one up.
+*/
+const LinkedInSearchFault = StatefulFault;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+var LinkedInSearchEmulatorInputInvalid = class extends Data.TaggedError("LinkedInSearchEmulatorInputInvalid") {
+	get message() {
+		return `Invalid LinkedIn search emulator ${this.input}: ${this.reason}`;
+	}
+};
+const inputInvalid = (input, reason) => new LinkedInSearchEmulatorInputInvalid({
+	input,
+	reason
+});
+/** The constant reason of a request on no emulated route shape. */
+const unrecognisedReason = "no emulated Exa or Enrich Layer route for this method and path";
+/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */
+const unrecognisedAuthorizationReason = "an unrecognisable Authorization header is not emulated";
+/**
+* Create a stateful LinkedIn search emulator on the `@emulators/core` custom runtime. Each call
+* has its own state, ledger, and faults. Rejects with `LinkedInSearchEmulatorInputInvalid` for an
+* invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.
+*/
+const makeLinkedInSearchEmulator = async (options = {}) => {
+	const initial = buildSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw inputInvalid("seed", initial);
+	checkBooleanDrills(options.drills, linkedInSearchEmulatorDrillKnobs, inputInvalid);
+	const drills = options.drills ?? {};
+	return makeStatefulEmulator({
+		routes: linkedInSearchApiRoutes,
+		env: { drills: {
+			defaultSearchWithoutText: drills.defaultSearchWithoutText === true,
+			numResultsIgnored: drills.numResultsIgnored === true,
+			profileAnswersEmptyObject: drills.profileAnswersEmptyObject === true,
+			emailAnswerOmitsEmail: drills.emailAnswerOmitsEmail === true,
+			exaUnauthorizedAs5xx: drills.exaUnauthorizedAs5xx === true,
+			enrichLayerUnauthorizedAs2xx: drills.enrichLayerUnauthorizedAs2xx === true,
+			absentProfileAs2xx: drills.absentProfileAs2xx === true
+		} },
+		initial,
+		buildSeed: buildSeedState,
+		recordHeaders: [{
+			name: "content-type",
+			json: false
+		}],
+		failClosed: {
+			unrecognised: unrecognisedReason,
+			unrecognisedAuthorization: unrecognisedAuthorizationReason
+		},
+		bearerDigest: linkedInSearchKeyDigest,
+		clearRuntime: () => void 0,
+		runtimeState: () => ({}),
+		seedSummary: (state) => ({
+			searches: state.searches.length,
+			profiles: state.profiles.length,
+			absentProfiles: state.absentProfileUrls.length,
+			exaRejectedKeys: state.exaRejectedKeyDigests.length,
+			enrichLayerRejectedKeys: state.enrichLayerRejectedKeyDigests.length
+		}),
+		inputInvalid
+	}, statefulCoreRuntime({
+		name: "linkedin-search",
+		initial,
+		decodeState,
+		inputInvalid
+	}));
+};
+//#endregion
+export { LinkedInSearchEmulatorInputInvalid, LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, LinkedInSearchEmulatorStateSchema, LinkedInSearchFault, LinkedInSearchFaultMatch, emulatorEvidenceHeader, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorErrorBodies, linkedInSearchEmulatorExaOrigin, linkedInSearchEmulatorRoutes, makeLinkedInSearchEmulator };
+
+//# sourceMappingURL=linkedin-search.mjs.map

package/dist/linkedin-search.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkedin-search.mjs","names":[],"sources":["../src/linkedin-search.ts"],"sourcesContent":["/**\n * Stateful LinkedIn search emulator (the Exa and Enrich Layer routes of the LinkedIn search\n * conformance cases: `POST /search` on `https://api.exa.ai`, and `GET /api/v2/profile` and\n * `GET /api/v2/profile/email` on `https://enrichlayer.com`), built on the upstream\n * `@emulators/core` custom runtime, with a request ledger, status faults, and an `/_emulate/*`\n * control plane.\n *\n * It never imports SDK code: its answers, error bodies, and default seed are copied as data from\n * the synthetic LinkedIn search conformance fixtures, and every route names the conformance cases\n * it follows in `linkedInSearchEmulatorRoutes`. Only the routes those seven cases send are\n * emulated, and every one is a read (nothing is ever written). Response behaviour comes only from\n * the fixtures, byte for byte: a search answers only the results the state holds for exactly its\n * query and `numResults` (the default seed holds the three the fixtures record, for `numResults`\n * 10, 3, and 2); a profile lookup answers a held profile, or the recorded 404 for a seeded absent\n * profile; an email lookup answers a held profile's recorded email. A key a seed marks as rejected\n * on an origin answers that origin's recorded 401 (the default seed rejects the synthetic invalid\n * keys the two unauthorized cases send). Anything else answers one ledgered 400 not-emulated and\n * uses up no fault. Every route answers only on its recorded origin (`fetchOn(origin)` serves one\n * behind a loopback rewrite).\n *\n * Fail closed, on the shared wrapper's fail-closed mode exactly as `/github` and `/google` use it:\n * a request is recognised only when its raw path is exactly an emulated route path under that\n * route's method, and any `Authorization` header is exactly `Bearer <token>` with a recognisable\n * bearer (the RFC 6750 `b64token` syntax, at least 8 characters, a first character in\n * `[G-Zg-z\\-._~+/]` other than `n`, `r`, `t`, `u`, and a character outside `[0-9.eE+-]`). Every\n * other request is ledgered and answered with constant text only (`/<unrecognised>`, a standard\n * method or `<other>`, an empty query, no body, a constant reason). A recognised request that\n * repeats the bearer anywhere (its raw path, the raw query or any query key or value, the recorded\n * `content-type` header, or its body, through the wrapper's fixpoint closure of tolerant\n * percent-decoding and JSON-unescaping, capped, where a cap refuses) is ledgered with constant text\n * only; any other has the bearer scrubbed from every ledgered field and reason. The bearer is never\n * stored, forwarded, or ledgered: routes see only its per-origin digest (the wrapper's opt-in\n * `bearerDigest`; SHA-256 of the origin, a space, and the key), which a plan compares with the\n * digests of the seed's rejected keys for that origin; the state holds only those digests, so a key\n * a request carries as its bearer, a rejected one included, never reaches the state or\n * `/_emulate/*` (a key sent as data elsewhere in a request is ledgered like any other text), and\n * seed errors are constant text (a category and a field path) that never quote one. Refusals never\n * echo a request's own query or body keys (the wrapper's constant-reason `exactQuery` and\n * `exactBodyKeys`).\n *\n * Request-shape latitude (`/linkedin-search`, the only accepted deviations): any bearer value in\n * the RFC 6750 `b64token` syntax (`[A-Za-z0-9\\-._~+/]+=*`) of at least 8 characters, starting with\n * a character in `[G-Zg-z\\-._~+/]` other than `n`, `r`, `t`, `u`, with at least one outside\n * `[0-9.eE+-]`, that occurs nowhere else in the request (never stored or ledgered; only its\n * per-origin digest is compared, with the digests of the keys the seed marks as rejected on that\n * origin); extra request headers; JSON key order; `content-type` media-type parameters on the\n * search; any percent-encoding of the `linkedin_profile_url` value that decodes once to the same\n * profile URL; and, with a key the seed marks as rejected on the request's origin, any search\n * `query` (one trimmed line of at most 500 characters) with any integer `numResults` from 1 to 100,\n * and any profile URL of the form `https://<host>/in/<slug>`, each answered the origin's\n * recorded 401. `Authorization` must be exactly `Bearer <token>` (that spelling, one space).\n * Everything else (other body keys or values, a `category` other than `people`, a `type` other than\n * `auto`, `contents` other than `{ \"text\": true }`, a search the state holds no answer for (another\n * query, or a `numResults` no seeded search of that query records), a profile URL the state holds\n * neither as a profile nor as absent, an email lookup of an absent profile, any query parameter on\n * the search, other, missing, or repeated query parameters on a lookup, a query parameter name in\n * any but its plain form (such as `%6cinkedin_profile_url`), empty query components such as a bare\n * `?` or a stray `&`, a body on a lookup, another origin, and a bearer repeated anywhere in the\n * request) is not emulated.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeLinkedInSearchEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport {\n  linkedInSearchApiRoutes,\n  linkedInSearchEmulatorDrillKnobs,\n  type LinkedInSearchApiEnv,\n  type LinkedInSearchEmulatorDrills\n} from './linkedin-search/api.ts'\nimport {\n  buildSeedState,\n  decodeState,\n  linkedInSearchKeyDigest,\n  type LinkedInSearchEmulatorSeed,\n  type LinkedInSearchEmulatorState\n} from './linkedin-search/state.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport {\n  StatefulFault,\n  StatefulFaultMatch,\n  checkBooleanDrills,\n  makeStatefulEmulator,\n  routeEvidence,\n  type StatefulCoverage,\n  type StatefulEmulatorApi,\n  type StatefulFaultState,\n  type StatefulInputKind,\n  type StatefulLedgerEntry\n} from './stateful-emulator.ts'\nimport { statefulCoreRuntime } from './stateful-core.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport {\n  linkedInSearchEmulatorErrorBodies,\n  type LinkedInSearchEmulatorDrills\n} from './linkedin-search/api.ts'\n\nexport {\n  LinkedInSearchEmulatorProfile,\n  LinkedInSearchEmulatorResult,\n  LinkedInSearchEmulatorSearch,\n  LinkedInSearchEmulatorSeed,\n  LinkedInSearchEmulatorStateSchema,\n  linkedInSearchEmulatorEnrichLayerOrigin,\n  linkedInSearchEmulatorExaOrigin,\n  type LinkedInSearchEmulatorState\n} from './linkedin-search/state.ts'\n\n/**\n * Route evidence manifest: every emulated route (all reads) and the conformance cases whose\n * (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers by\n * construction (both come from one route table).\n */\nexport const linkedInSearchEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> =\n  linkedInSearchApiRoutes.map(routeEvidence)\n\n/**\n * Optional fault filter; an omitted field matches every request. `method` is the HTTP method;\n * `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the\n * manifest (another value is rejected when the fault is added).\n */\nexport const LinkedInSearchFaultMatch = StatefulFaultMatch\n\nexport type LinkedInSearchFaultMatch = typeof StatefulFaultMatch.Type\n\n/**\n * A status fault (400-599): answer matching requests with this status, headers, and body instead\n * of the route's answer. The body defaults to `{ error: { type: 'emulator_fault', message } }`;\n * `count` limits how many requests it answers. Only a request the emulator would answer reaches a\n * fault: a request that is not emulated, by its shape or by the state, never uses one up.\n */\nexport const LinkedInSearchFault = StatefulFault\n\nexport type LinkedInSearchFault = StatefulFault\n\nexport type LinkedInSearchFaultState = StatefulFaultState\n\nexport type LinkedInSearchLedgerEntry = StatefulLedgerEntry\n\nexport type LinkedInSearchCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */\nexport class LinkedInSearchEmulatorInputInvalid extends Data.TaggedError(\n  'LinkedInSearchEmulatorInputInvalid'\n)<{\n  readonly input: StatefulInputKind\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid LinkedIn search emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type LinkedInSearchEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entities. */\n  readonly seed?: LinkedInSearchEmulatorSeed\n  /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */\n  readonly drills?: LinkedInSearchEmulatorDrills\n}\n\nexport type LinkedInSearchEmulator = StatefulEmulatorApi<\n  LinkedInSearchEmulatorState,\n  LinkedInSearchEmulatorSeed\n>\n\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new LinkedInSearchEmulatorInputInvalid({ input, reason })\n\n/** The constant reason of a request on no emulated route shape. */\nconst unrecognisedReason = 'no emulated Exa or Enrich Layer route for this method and path'\n\n/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */\nconst unrecognisedAuthorizationReason = 'an unrecognisable Authorization header is not emulated'\n\n/**\n * Create a stateful LinkedIn search emulator on the `@emulators/core` custom runtime. Each call\n * has its own state, ledger, and faults. Rejects with `LinkedInSearchEmulatorInputInvalid` for an\n * invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.\n */\nexport const makeLinkedInSearchEmulator = async (\n  options: LinkedInSearchEmulatorOptions = {}\n): Promise<LinkedInSearchEmulator> => {\n  const initial = buildSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw inputInvalid('seed', initial)\n  }\n\n  checkBooleanDrills(options.drills, linkedInSearchEmulatorDrillKnobs, inputInvalid)\n\n  const drills = options.drills ?? {}\n\n  const env: LinkedInSearchApiEnv = {\n    drills: {\n      defaultSearchWithoutText: drills.defaultSearchWithoutText === true,\n      numResultsIgnored: drills.numResultsIgnored === true,\n      profileAnswersEmptyObject: drills.profileAnswersEmptyObject === true,\n      emailAnswerOmitsEmail: drills.emailAnswerOmitsEmail === true,\n      exaUnauthorizedAs5xx: drills.exaUnauthorizedAs5xx === true,\n      enrichLayerUnauthorizedAs2xx: drills.enrichLayerUnauthorizedAs2xx === true,\n      absentProfileAs2xx: drills.absentProfileAs2xx === true\n    }\n  }\n\n  return makeStatefulEmulator<\n    LinkedInSearchEmulatorState,\n    LinkedInSearchApiEnv,\n    LinkedInSearchEmulatorSeed\n  >(\n    {\n      routes: linkedInSearchApiRoutes,\n      env,\n      initial,\n      buildSeed: buildSeedState,\n      recordHeaders: [{ name: 'content-type', json: false }],\n      failClosed: {\n        unrecognised: unrecognisedReason,\n        unrecognisedAuthorization: unrecognisedAuthorizationReason\n      },\n      bearerDigest: linkedInSearchKeyDigest,\n      // No cursors or other runtime data.\n      clearRuntime: () => undefined,\n      runtimeState: () => ({}),\n      seedSummary: state => ({\n        searches: state.searches.length,\n        profiles: state.profiles.length,\n        absentProfiles: state.absentProfileUrls.length,\n        exaRejectedKeys: state.exaRejectedKeyDigests.length,\n        enrichLayerRejectedKeys: state.enrichLayerRejectedKeyDigests.length\n      }),\n      inputInvalid\n    },\n    statefulCoreRuntime({ name: 'linkedin-search', initial, decodeState, inputInvalid })\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHA,MAAa,+BACX,wBAAwB,IAAI,aAAa;;;;;;AAO3C,MAAa,2BAA2B;;;;;;;AAUxC,MAAa,sBAAsB;;AAWnC,IAAa,qCAAb,cAAwD,KAAK,YAC3D,oCACF,EAGG;CACD,IAAa,UAAkB;EAC7B,OAAO,oCAAoC,KAAK,MAAM,IAAI,KAAK;CACjE;AACF;AAcA,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,mCAAmC;CAAE;CAAO;AAAO,CAAC;;AAG1D,MAAM,qBAAqB;;AAG3B,MAAM,kCAAkC;;;;;;AAOxC,MAAa,6BAA6B,OACxC,UAAyC,CAAC,MACN;CACpC,MAAM,UAAU,eAAe,QAAQ,QAAQ,CAAC,CAAC;CAEjD,IAAI,UAAU,SAAS,OAAO,GAC5B,MAAM,aAAa,QAAQ,OAAO;CAGpC,mBAAmB,QAAQ,QAAQ,kCAAkC,YAAY;CAEjF,MAAM,SAAS,QAAQ,UAAU,CAAC;CAclC,OAAO,qBAKL;EACE,QAAQ;EACR,KAAA,EAlBF,QAAQ;GACN,0BAA0B,OAAO,6BAA6B;GAC9D,mBAAmB,OAAO,sBAAsB;GAChD,2BAA2B,OAAO,8BAA8B;GAChE,uBAAuB,OAAO,0BAA0B;GACxD,sBAAsB,OAAO,yBAAyB;GACtD,8BAA8B,OAAO,iCAAiC;GACtE,oBAAoB,OAAO,uBAAuB;EACpD,EAUI;EACF;EACA,WAAW;EACX,eAAe,CAAC;GAAE,MAAM;GAAgB,MAAM;EAAM,CAAC;EACrD,YAAY;GACV,cAAc;GACd,2BAA2B;EAC7B;EACA,cAAc;EAEd,oBAAoB,KAAA;EACpB,qBAAqB,CAAC;EACtB,cAAa,WAAU;GACrB,UAAU,MAAM,SAAS;GACzB,UAAU,MAAM,SAAS;GACzB,gBAAgB,MAAM,kBAAkB;GACxC,iBAAiB,MAAM,sBAAsB;GAC7C,yBAAyB,MAAM,8BAA8B;EAC/D;EACA;CACF,GACA,oBAAoB;EAAE,MAAM;EAAmB;EAAS;EAAa;CAAa,CAAC,CACrF;AACF"}

package/dist/mcp/api.d.mts

@@ -0,0 +1,44 @@
+import { StatefulRoute } from "../stateful-emulator.mjs";
+import { McpRecordedFixture } from "./recordings.mjs";
+import { McpEmulatorState, McpRuntime } from "./state.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/mcp/api.d.ts
+/** Drill knobs (tests only): each makes the emulator disagree with exactly one case's claim. */
+type McpEmulatorDrills = {
+  /** `mcp.negotiation.era` (modern): the discover answer also carries a JSON-RPC error. */readonly discoverCarriesErrorResponse?: boolean; /** `mcp.modern.stateless`: the modern discover result lacks `resultType`. */
+  readonly discoverWithoutResultType?: boolean; /** `mcp.legacy.session`: minted session ids hold a space (not visible ASCII). */
+  readonly sessionIdNotVisibleAscii?: boolean; /** `mcp.transport.response-encoding` (modern): the discover answer holds its response twice. */
+  readonly discoverAnsweredTwice?: boolean; /** `mcp.tools.list`: the listing marks the write tool `readOnlyHint: true`. */
+  readonly writeToolMarkedReadOnly?: boolean; /** `mcp.tools.call-read`: the read call answers `isError: true`. */
+  readonly readCallAnswersToolError?: boolean; /** `mcp.tools.call-tool-error`: invalid arguments answer a JSON-RPC error. */
+  readonly invalidCallAnswersRpcError?: boolean; /** `mcp.errors.unknown-tool`: the absent tool answers a tool result. */
+  readonly absentCallAnswersResult?: boolean; /** `mcp.auth.rejected`: the 401 carries no `WWW-Authenticate` challenge. */
+  readonly unauthorizedWithoutChallenge?: boolean;
+};
+declare const mcpEmulatorDrillKnobs: ReadonlyArray<keyof McpEmulatorDrills>;
+type McpApiEnv = {
+  readonly drills: Readonly<Record<keyof McpEmulatorDrills, boolean>>; /** The digest of the reserved invalid credential on the emulated origin. */
+  readonly reservedDigest: string; /** Runtime data the commits advance (never in the state). */
+  readonly runtime: McpRuntime;
+};
+type McpRoute = StatefulRoute<McpEmulatorState, McpApiEnv>;
+type RpcId = string | number;
+/**
+ * Where a copied recording is not in the canonical form id substitution relies on: every JSON
+ * answer body, and every SSE `data:` payload, must equal `JSON.stringify(JSON.parse(text))`, and
+ * every SSE data line must start with `data: `. `makeMcpEmulator` throws on any problem, so a
+ * recording copied in another form (escapes such as `\u00e9` or `\/`, numbers such as `1.0`,
+ * spacing) fails loudly instead of answering bytes the substitution would rewrite.
+ */
+declare const mcpRecordingProblems: (fixtures: ReadonlyArray<McpRecordedFixture>) => ReadonlyArray<string>;
+/**
+ * A JSON-RPC request id of the emulated form: an integer from 0 to 2^53 - 1, or 1 to 64 printable
+ * ASCII characters.
+ */
+declare const isMcpEmulatedRequestId: (id: Schema.Json | undefined) => id is RpcId;
+/** The route table: one wire route per recorded HTTP shape, each with its manifest variants. */
+declare const mcpApiRoutes: ReadonlyArray<McpRoute>;
+//#endregion
+export { McpApiEnv, McpEmulatorDrills, isMcpEmulatedRequestId, mcpApiRoutes, mcpEmulatorDrillKnobs, mcpRecordingProblems };
+//# sourceMappingURL=api.d.mts.map

package/dist/mcp/api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/mcp/api.ts"],"mappings":";;;;;;;KAqDY,iBAAA;EAAA,kGAED,4BAAA;WAEA,yBAAA,YAFA;EAAA,SAIA,wBAAA;EAAA,SAEA,qBAAA,YAEA;EAAA,SAAA,uBAAA,YAIA;EAAA,SAFA,wBAAA,YAMA;EAAA,SAJA,0BAAA,YAI4B;EAAA,SAF5B,uBAAA,YAeV;EAAA,SAbU,4BAAA;AAAA;AAAA,cAGE,qBAAA,EAAuB,aAAa,OAAO,iBAAA;AAAA,KAY5C,SAAA;EAAA,SACD,MAAA,EAAQ,QAAA,CAAS,MAAA,OAAa,iBAAA;WAE9B,cAAA,UAFiB;EAAA,SAIjB,OAAA,EAAS,UAAA;AAAA;AAAA,KAGf,QAAA,GAAW,aAAA,CAAc,gBAAA,EAAkB,SAAA;AAAA,KAE3C,KAAA;;;;;;;;cA8MQ,oBAAA,GACX,QAAA,EAAU,aAAA,CAAc,kBAAA,MACvB,aAAA;AArN2B;AAC7B;;;AAD6B,cAySjB,sBAAA,GAA0B,EAAA,EAAI,MAAA,CAAO,IAAA,iBAAmB,EAAA,IAAM,KAEf;;cA4lB/C,YAAA,EAAc,aAAa,CAAC,QAAA"}