@yolk-sdk/emulators 0.1.0-canary.96

package/dist/google.mjs

@@ -0,0 +1,210 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, checkBooleanDrills, makeStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { googleEmulatorApisOrigin, googleEmulatorDrillKnobs, googleEmulatorGmailOrigin } from "./google/shared.mjs";
+import { GoogleEmulatorAttachment, GoogleEmulatorCalendar, GoogleEmulatorCalendarEvent, GoogleEmulatorDraft, GoogleEmulatorDriveFile, GoogleEmulatorEventBoundary, GoogleEmulatorGmailLabel, GoogleEmulatorGmailMessage, GoogleEmulatorImpliedMessage, GoogleEmulatorPracticeAddress, GoogleEmulatorProfile, GoogleEmulatorSeed, GoogleEmulatorStateSchema, buildSeedState, decodeState } from "./google/state.mjs";
+import { calendarRoutes } from "./google/calendar.mjs";
+import { driveRoutes } from "./google/drive.mjs";
+import { gmailRoutes } from "./google/gmail.mjs";
+import { Data, Predicate } from "effect";
+//#region src/google.ts
+/**
+* Stateful Google emulator (the Gmail, Calendar, and Drive routes the Google conformance cases
+* send), 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 wire shapes, error envelopes, and default seed are copied as data
+* from the synthetic Google conformance fixtures, and every route names the conformance cases it
+* follows in `googleEmulatorRoutes`. Only the routes those thirteen cases (with their cleanup)
+* send are emulated: Gmail on `https://gmail.googleapis.com` (`/gmail/v1/users/me/...` and the
+* multipart send upload), Calendar and Drive on `https://www.googleapis.com` (`/calendar/v3` and
+* `/drive/v3`). Each route answers only on its recorded origin (`fetchOn(origin)` serves one
+* origin behind a loopback rewrite). Response behaviour comes only from the fixtures: anything
+* they do not show answers one ledgered 400 not-emulated, writes nothing, and uses up no fault.
+* That includes an empty listing and every read of the leftover lookup
+* (`findGoogleConformanceLeftovers`, whose label listing, draft search, and free-text event query
+* no fixture records): the lookup fails, and runners print their lookup-failed WARN.
+*
+* The practice send (`google.gmail.send-practice-address`) is irreversible on Gmail. Here it is
+* only recorded in the state (the sent message reads back; nothing is delivered anywhere), and only
+* the recorded 7-bit message whose sole recipient header is `To: <the seeded practice address>`
+* is accepted, and only while that address is the recorded `practice@example.test` (the recorded
+* `sizeEstimate` covers it, as it covers the draft and send subjects, which therefore take only a
+* run id of the fixtures' 13-character length).
+*
+* Fail closed: Google follows the shared fail-closed rule of `src/stateful-emulator.ts` (its opt-in
+* `failClosed` mode, the same rule as `/github`). Every route parameter has a raw pattern matched
+* in full, so a request is recognised only when its raw path is exactly an emulated route shape
+* under that route's method and any `Authorization` header is exactly `Bearer <token>` with a
+* recognisable bearer (below); 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).
+* The bearer value is never compared against anything, stored, forwarded, or ledgered. A recognised
+* request that repeats it in its raw path, any path segment, the query or any query key or value,
+* the recorded `content-type` header, or its raw body (the multipart send body included), or, on
+* the draft compose and update routes, in the base64url-decoded MIME of `message.raw` (Gmail's own
+* wire format wraps the draft this way; the routes give it to the wrapper as a decoded view), is
+* ledgered as the constant credential-repeat entry, checked through the wrapper's fixpoint closure
+* of a tolerant percent-decode and a tolerant JSON-unescape; any other recognised request has the
+* bearer scrubbed from its ledgered fields and every not-emulated reason. A `message.raw` the route
+* would refuse (anything but canonical unpadded base64url of exactly the recorded draft MIME, the
+* run id aside) makes the view throw a `DecodedViewRefusal` with one of the route's declared
+* constant reasons (`viewRefusalReasons`: the canonical-base64url reason, the
+* other-than-the-recorded-run-draft reason, the 13-character run-id reason, the extra-key reason),
+* which the wrapper ledgers in the constant entry before anything is recorded (or
+* `the request body repeats the credential` when the raw decodes cleanly to text holding the
+* bearer), so a refused `message.raw` never reaches the ledger. Google refusals use the wrapper's
+* constant-reason `exactQuery` and `exactBodyKeys`, so they never echo a request's own query or
+* body keys.
+*
+* Request-shape latitude (`/google`, 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+-]` (Google's `ya29.…` access tokens qualify), that occurs nowhere else in the request
+* (never compared against anything, stored, or ledgered); extra request headers (except
+* `X-Goog-Drive-Resource-Keys`, which no fixture sends); JSON key order; `content-type` media-type
+* parameters on JSON requests; query parameters in any order; any `run-` run id (at most 40
+* characters) in a run-scoped label name, event summary, or folder name; in a draft subject
+* (compose and update) and the sent subject, only a run id of exactly 13 characters, the length of
+* the fixtures' `run-synthetic`, because the recorded `sizeEstimate` of the draft and sent messages
+* (answered by their message reads and the draft thread) covers the subject; on the practice send,
+* a `content-type` of exactly `multipart/related; boundary=<b>` with any one unquoted boundary of 1
+* to 70 `[A-Za-z0-9_]` characters and no other parameter; a `gmail.list` `maxResults` from 1 to
+* 500, a `calendar.list_events` `maxResults` from 1 to 2500, and a `drive.list_files` `pageSize`
+* from 1 to 1000; any `timeMin` before `timeMax` (RFC 3339 instants with a real calendar date, hour
+* 0 to 23, minute and second 0 to 59, and a `Z` or in-range numeric offset); any id of an item the
+* state holds where a fixture has an id (writes: only items created here, plus label changes,
+* trash, and untrash of a stored non-draft message); and, for an id the state does not hold, only
+* the recorded not-found answers (a `format=minimal` read of a 16-hex-digit message id, a read of a
+* `Label_<1 to 999999999>` label, a delete of an `r-<digits>` draft, and a Drive file read). A seed
+* may set another `practiceAddress`, but then every send is refused, since the recorded
+* `sizeEstimate` of the sent message also covers the address: the send answers only while the
+* seeded address is the recorded `practice@example.test`. On the draft compose and update routes,
+* `message.raw` must be canonical unpadded base64url of exactly the recorded draft MIME of that
+* route, the run id aside; any other `message.raw` (line-wrapped, the standard alphabet, padded,
+* with a stray character, or with MIME-level encodings such as RFC 2047 encoded-words,
+* quoted-printable, or UTF-16) is refused before anything is recorded or a fault is decided, as a
+* constant entry with the route's own declared reason
+* (`message.raw must be canonical base64url UTF-8 MIME`,
+* `a draft compose other than the recorded run draft is not emulated` or its `update` form, the
+* 13-character run-id reason, or `message has a key this route does not take`), or
+* `the request body repeats the credential` when that raw decodes cleanly to text holding the
+* bearer, so a refused `message.raw` never reaches the ledger and an admitted one is the recorded
+* text. `Authorization` must be exactly `Bearer <token>` (that spelling, one space). Everything
+* else (other keys, values, formats, query parameters, empty query components such as a bare `?` or
+* a stray `&`, recorded headers such as Drive's `accept: application/json` missing, another origin,
+* repeated query parameters, any recipient but the seeded practice address, a draft or send run id
+* of another length, a bearer repeated anywhere in the request, including base64url-encoded inside
+* a draft's `message.raw`, and page tokens not issued for the same list since the last reset or
+* seed, or whose list changed) is not emulated.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeGoogleEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+const googleApiRoutes = [
+	...gmailRoutes,
+	...calendarRoutes,
+	...driveRoutes
+];
+/**
+* Route evidence manifest: every emulated route, whether it writes, 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). Every route cites at least one case.
+*/
+const googleEmulatorRoutes = googleApiRoutes.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 GoogleFaultMatch = StatefulFaultMatch;
+/**
+* A status fault (400-599): answer matching requests with this status, headers, and body instead
+* of the route's write, so nothing is written. 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 GoogleFault = StatefulFault;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+var GoogleEmulatorInputInvalid = class extends Data.TaggedError("GoogleEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Google emulator ${this.input}: ${this.reason}`;
+	}
+};
+/** The constant reason of a request on no emulated route shape (nothing of it is ledgered). */
+const googleUnrecognisedReason = "no emulated Google route for this method and path";
+/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */
+const googleUnrecognisedAuthorizationReason = "an unrecognisable Authorization header is not emulated";
+const inputInvalid = (input, reason) => new GoogleEmulatorInputInvalid({
+	input,
+	reason
+});
+/**
+* Create a stateful Google emulator on the `@emulators/core` custom runtime. Each call has its
+* own state, ledger, faults, and page tokens. Rejects with `GoogleEmulatorInputInvalid` for an
+* invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.
+*/
+const makeGoogleEmulator = async (options = {}) => {
+	const initial = buildSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw inputInvalid("seed", initial);
+	checkBooleanDrills(options.drills, googleEmulatorDrillKnobs, inputInvalid);
+	const drills = options.drills ?? {};
+	const env = {
+		now: options.now ?? (() => Date.now()),
+		drills: {
+			gmailPageRepeats: drills.gmailPageRepeats === true,
+			attachmentStandardBase64: drills.attachmentStandardBase64 === true,
+			notFoundWithoutMessage: drills.notFoundWithoutMessage === true,
+			labelDeleteKeepsOnMessages: drills.labelDeleteKeepsOnMessages === true,
+			draftUpdateKeepsContent: drills.draftUpdateKeepsContent === true,
+			trashAnswerOmitsTrash: drills.trashAnswerOmitsTrash === true,
+			sentMessageWithoutTo: drills.sentMessageWithoutTo === true,
+			calendarPageRepeats: drills.calendarPageRepeats === true,
+			eventPatchKeepsSummary: drills.eventPatchKeepsSummary === true,
+			repeatedEventDeleteConflict: drills.repeatedEventDeleteConflict === true,
+			drivePageRepeats: drills.drivePageRepeats === true,
+			getFileWithoutParents: drills.getFileWithoutParents === true,
+			listIncludesTrashed: drills.listIncludesTrashed === true
+		},
+		pageTokens: /* @__PURE__ */ new Map(),
+		generation: { current: 0 },
+		firstIssued: /* @__PURE__ */ new Map()
+	};
+	return makeStatefulEmulator({
+		routes: googleApiRoutes,
+		env,
+		initial,
+		buildSeed: buildSeedState,
+		requestProblem: (header) => header("x-goog-drive-resource-keys") === void 0 ? void 0 : "X-Goog-Drive-Resource-Keys is not emulated (no fixture sends it)",
+		recordHeaders: [{
+			name: "content-type",
+			json: false
+		}],
+		clearRuntime: () => {
+			env.pageTokens.clear();
+			env.generation.current += 1;
+		},
+		runtimeState: () => ({ pageTokens: env.pageTokens.size }),
+		seedSummary: (state) => ({
+			messages: state.messages.length,
+			events: state.events.length,
+			files: state.files.length
+		}),
+		inputInvalid,
+		failClosed: {
+			unrecognised: googleUnrecognisedReason,
+			unrecognisedAuthorization: googleUnrecognisedAuthorizationReason
+		}
+	}, statefulCoreRuntime({
+		name: "google",
+		initial,
+		decodeState,
+		inputInvalid
+	}));
+};
+//#endregion
+export { GoogleEmulatorAttachment, GoogleEmulatorCalendar, GoogleEmulatorCalendarEvent, GoogleEmulatorDraft, GoogleEmulatorDriveFile, GoogleEmulatorEventBoundary, GoogleEmulatorGmailLabel, GoogleEmulatorGmailMessage, GoogleEmulatorImpliedMessage, GoogleEmulatorInputInvalid, GoogleEmulatorPracticeAddress, GoogleEmulatorProfile, GoogleEmulatorSeed, GoogleEmulatorStateSchema, GoogleFault, GoogleFaultMatch, emulatorEvidenceHeader, googleEmulatorApisOrigin, googleEmulatorGmailOrigin, googleEmulatorRoutes, makeGoogleEmulator };
+
+//# sourceMappingURL=google.mjs.map

package/dist/google.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.mjs","names":[],"sources":["../src/google.ts"],"sourcesContent":["/**\n * Stateful Google emulator (the Gmail, Calendar, and Drive routes the Google conformance cases\n * send), built on the upstream `@emulators/core` custom runtime, with a request ledger, status\n * faults, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes, error envelopes, and default seed are copied as data\n * from the synthetic Google conformance fixtures, and every route names the conformance cases it\n * follows in `googleEmulatorRoutes`. Only the routes those thirteen cases (with their cleanup)\n * send are emulated: Gmail on `https://gmail.googleapis.com` (`/gmail/v1/users/me/...` and the\n * multipart send upload), Calendar and Drive on `https://www.googleapis.com` (`/calendar/v3` and\n * `/drive/v3`). Each route answers only on its recorded origin (`fetchOn(origin)` serves one\n * origin behind a loopback rewrite). Response behaviour comes only from the fixtures: anything\n * they do not show answers one ledgered 400 not-emulated, writes nothing, and uses up no fault.\n * That includes an empty listing and every read of the leftover lookup\n * (`findGoogleConformanceLeftovers`, whose label listing, draft search, and free-text event query\n * no fixture records): the lookup fails, and runners print their lookup-failed WARN.\n *\n * The practice send (`google.gmail.send-practice-address`) is irreversible on Gmail. Here it is\n * only recorded in the state (the sent message reads back; nothing is delivered anywhere), and only\n * the recorded 7-bit message whose sole recipient header is `To: <the seeded practice address>`\n * is accepted, and only while that address is the recorded `practice@example.test` (the recorded\n * `sizeEstimate` covers it, as it covers the draft and send subjects, which therefore take only a\n * run id of the fixtures' 13-character length).\n *\n * Fail closed: Google follows the shared fail-closed rule of `src/stateful-emulator.ts` (its opt-in\n * `failClosed` mode, the same rule as `/github`). Every route parameter has a raw pattern matched\n * in full, so a request is recognised only when its raw path is exactly an emulated route shape\n * under that route's method and any `Authorization` header is exactly `Bearer <token>` with a\n * recognisable bearer (below); every other request is ledgered and answered with constant text only\n * (`/<unrecognised>`, a standard method or `<other>`, an empty query, no body, a constant reason).\n * The bearer value is never compared against anything, stored, forwarded, or ledgered. A recognised\n * request that repeats it in its raw path, any path segment, the query or any query key or value,\n * the recorded `content-type` header, or its raw body (the multipart send body included), or, on\n * the draft compose and update routes, in the base64url-decoded MIME of `message.raw` (Gmail's own\n * wire format wraps the draft this way; the routes give it to the wrapper as a decoded view), is\n * ledgered as the constant credential-repeat entry, checked through the wrapper's fixpoint closure\n * of a tolerant percent-decode and a tolerant JSON-unescape; any other recognised request has the\n * bearer scrubbed from its ledgered fields and every not-emulated reason. A `message.raw` the route\n * would refuse (anything but canonical unpadded base64url of exactly the recorded draft MIME, the\n * run id aside) makes the view throw a `DecodedViewRefusal` with one of the route's declared\n * constant reasons (`viewRefusalReasons`: the canonical-base64url reason, the\n * other-than-the-recorded-run-draft reason, the 13-character run-id reason, the extra-key reason),\n * which the wrapper ledgers in the constant entry before anything is recorded (or\n * `the request body repeats the credential` when the raw decodes cleanly to text holding the\n * bearer), so a refused `message.raw` never reaches the ledger. Google refusals use the wrapper's\n * constant-reason `exactQuery` and `exactBodyKeys`, so they never echo a request's own query or\n * body keys.\n *\n * Request-shape latitude (`/google`, the only accepted deviations): any bearer value in the RFC\n * 6750 `b64token` syntax (`[A-Za-z0-9\\-._~+/]+=*`) of at least 8 characters, starting with a\n * character in `[G-Zg-z\\-._~+/]` other than `n`, `r`, `t`, `u`, with at least one outside\n * `[0-9.eE+-]` (Google's `ya29.…` access tokens qualify), that occurs nowhere else in the request\n * (never compared against anything, stored, or ledgered); extra request headers (except\n * `X-Goog-Drive-Resource-Keys`, which no fixture sends); JSON key order; `content-type` media-type\n * parameters on JSON requests; query parameters in any order; any `run-` run id (at most 40\n * characters) in a run-scoped label name, event summary, or folder name; in a draft subject\n * (compose and update) and the sent subject, only a run id of exactly 13 characters, the length of\n * the fixtures' `run-synthetic`, because the recorded `sizeEstimate` of the draft and sent messages\n * (answered by their message reads and the draft thread) covers the subject; on the practice send,\n * a `content-type` of exactly `multipart/related; boundary=<b>` with any one unquoted boundary of 1\n * to 70 `[A-Za-z0-9_]` characters and no other parameter; a `gmail.list` `maxResults` from 1 to\n * 500, a `calendar.list_events` `maxResults` from 1 to 2500, and a `drive.list_files` `pageSize`\n * from 1 to 1000; any `timeMin` before `timeMax` (RFC 3339 instants with a real calendar date, hour\n * 0 to 23, minute and second 0 to 59, and a `Z` or in-range numeric offset); any id of an item the\n * state holds where a fixture has an id (writes: only items created here, plus label changes,\n * trash, and untrash of a stored non-draft message); and, for an id the state does not hold, only\n * the recorded not-found answers (a `format=minimal` read of a 16-hex-digit message id, a read of a\n * `Label_<1 to 999999999>` label, a delete of an `r-<digits>` draft, and a Drive file read). A seed\n * may set another `practiceAddress`, but then every send is refused, since the recorded\n * `sizeEstimate` of the sent message also covers the address: the send answers only while the\n * seeded address is the recorded `practice@example.test`. On the draft compose and update routes,\n * `message.raw` must be canonical unpadded base64url of exactly the recorded draft MIME of that\n * route, the run id aside; any other `message.raw` (line-wrapped, the standard alphabet, padded,\n * with a stray character, or with MIME-level encodings such as RFC 2047 encoded-words,\n * quoted-printable, or UTF-16) is refused before anything is recorded or a fault is decided, as a\n * constant entry with the route's own declared reason\n * (`message.raw must be canonical base64url UTF-8 MIME`,\n * `a draft compose other than the recorded run draft is not emulated` or its `update` form, the\n * 13-character run-id reason, or `message has a key this route does not take`), or\n * `the request body repeats the credential` when that raw decodes cleanly to text holding the\n * bearer, so a refused `message.raw` never reaches the ledger and an admitted one is the recorded\n * text. `Authorization` must be exactly `Bearer <token>` (that spelling, one space). Everything\n * else (other keys, values, formats, query parameters, empty query components such as a bare `?` or\n * a stray `&`, recorded headers such as Drive's `accept: application/json` missing, another origin,\n * repeated query parameters, any recipient but the seeded practice address, a draft or send run id\n * of another length, a bearer repeated anywhere in the request, including base64url-encoded inside\n * a draft's `message.raw`, and page tokens not issued for the same list since the last reset or\n * seed, or whose list changed) is not emulated.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeGoogleEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport { calendarRoutes } from './google/calendar.ts'\nimport { driveRoutes } from './google/drive.ts'\nimport { gmailRoutes } from './google/gmail.ts'\nimport {\n  googleEmulatorDrillKnobs,\n  type GoogleApiEnv,\n  type GoogleEmulatorDrills,\n  type GoogleRoute\n} from './google/shared.ts'\nimport {\n  buildSeedState,\n  decodeState,\n  type GoogleEmulatorSeed,\n  type GoogleEmulatorState\n} from './google/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  googleEmulatorApisOrigin,\n  googleEmulatorGmailOrigin,\n  type GoogleEmulatorDrills\n} from './google/shared.ts'\n\nexport {\n  GoogleEmulatorAttachment,\n  GoogleEmulatorCalendar,\n  GoogleEmulatorCalendarEvent,\n  GoogleEmulatorDraft,\n  GoogleEmulatorDriveFile,\n  GoogleEmulatorEventBoundary,\n  GoogleEmulatorGmailLabel,\n  GoogleEmulatorGmailMessage,\n  GoogleEmulatorImpliedMessage,\n  GoogleEmulatorPracticeAddress,\n  GoogleEmulatorProfile,\n  GoogleEmulatorSeed,\n  GoogleEmulatorStateSchema,\n  type GoogleEmulatorState\n} from './google/state.ts'\n\nconst googleApiRoutes: ReadonlyArray<GoogleRoute> = [\n  ...gmailRoutes,\n  ...calendarRoutes,\n  ...driveRoutes\n]\n\n/**\n * Route evidence manifest: every emulated route, whether it writes, and the conformance cases\n * whose (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers\n * by construction (both come from one route table). Every route cites at least one case.\n */\nexport const googleEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> =\n  googleApiRoutes.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 GoogleFaultMatch = StatefulFaultMatch\n\nexport type GoogleFaultMatch = 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 write, so nothing is written. The body defaults to\n * `{ error: { type: 'emulator_fault', message } }`; `count` limits how many requests it answers.\n * Only a request the emulator would answer reaches a fault: a request that is not emulated, by\n * its shape or by the state, never uses one up.\n */\nexport const GoogleFault = StatefulFault\n\nexport type GoogleFault = StatefulFault\n\nexport type GoogleFaultState = StatefulFaultState\n\nexport type GoogleLedgerEntry = StatefulLedgerEntry\n\nexport type GoogleCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */\nexport class GoogleEmulatorInputInvalid extends Data.TaggedError('GoogleEmulatorInputInvalid')<{\n  readonly input: StatefulInputKind\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Google emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type GoogleEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */\n  readonly seed?: GoogleEmulatorSeed\n  /**\n   * Clock in epoch milliseconds (created and updated event times, Drive folder times, and the\n   * sent message's `Date` header). Defaults to `Date.now`.\n   */\n  readonly now?: () => number\n  /** Drill knobs (tests only): make the emulator disagree with one conformance case. */\n  readonly drills?: GoogleEmulatorDrills\n}\n\nexport type GoogleEmulator = StatefulEmulatorApi<GoogleEmulatorState, GoogleEmulatorSeed>\n\n/** The constant reason of a request on no emulated route shape (nothing of it is ledgered). */\nconst googleUnrecognisedReason = 'no emulated Google route for this method and path'\n\n/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */\nconst googleUnrecognisedAuthorizationReason =\n  'an unrecognisable Authorization header is not emulated'\n\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new GoogleEmulatorInputInvalid({ input, reason })\n\n/**\n * Create a stateful Google emulator on the `@emulators/core` custom runtime. Each call has its\n * own state, ledger, faults, and page tokens. Rejects with `GoogleEmulatorInputInvalid` for an\n * invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.\n */\nexport const makeGoogleEmulator = async (\n  options: GoogleEmulatorOptions = {}\n): Promise<GoogleEmulator> => {\n  const initial = buildSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw inputInvalid('seed', initial)\n  }\n\n  checkBooleanDrills(options.drills, googleEmulatorDrillKnobs, inputInvalid)\n\n  const drills = options.drills ?? {}\n\n  const env: GoogleApiEnv = {\n    now: options.now ?? (() => Date.now()),\n    drills: {\n      gmailPageRepeats: drills.gmailPageRepeats === true,\n      attachmentStandardBase64: drills.attachmentStandardBase64 === true,\n      notFoundWithoutMessage: drills.notFoundWithoutMessage === true,\n      labelDeleteKeepsOnMessages: drills.labelDeleteKeepsOnMessages === true,\n      draftUpdateKeepsContent: drills.draftUpdateKeepsContent === true,\n      trashAnswerOmitsTrash: drills.trashAnswerOmitsTrash === true,\n      sentMessageWithoutTo: drills.sentMessageWithoutTo === true,\n      calendarPageRepeats: drills.calendarPageRepeats === true,\n      eventPatchKeepsSummary: drills.eventPatchKeepsSummary === true,\n      repeatedEventDeleteConflict: drills.repeatedEventDeleteConflict === true,\n      drivePageRepeats: drills.drivePageRepeats === true,\n      getFileWithoutParents: drills.getFileWithoutParents === true,\n      listIncludesTrashed: drills.listIncludesTrashed === true\n    },\n    pageTokens: new Map(),\n    generation: { current: 0 },\n    firstIssued: new Map()\n  }\n\n  return makeStatefulEmulator<GoogleEmulatorState, GoogleApiEnv, GoogleEmulatorSeed>(\n    {\n      routes: googleApiRoutes,\n      env,\n      initial,\n      buildSeed: buildSeedState,\n      requestProblem: header =>\n        header('x-goog-drive-resource-keys') === undefined\n          ? undefined\n          : 'X-Goog-Drive-Resource-Keys is not emulated (no fixture sends it)',\n      // `content-type` only (never a credential header); the bearer is checked in it too.\n      recordHeaders: [{ name: 'content-type', json: false }],\n      // Page token values never cross a reset or seed: the generation makes later tokens distinct.\n      clearRuntime: () => {\n        env.pageTokens.clear()\n        env.generation.current += 1\n      },\n      runtimeState: () => ({ pageTokens: env.pageTokens.size }),\n      seedSummary: state => ({\n        messages: state.messages.length,\n        events: state.events.length,\n        files: state.files.length\n      }),\n      inputInvalid,\n      failClosed: {\n        unrecognised: googleUnrecognisedReason,\n        unrecognisedAuthorization: googleUnrecognisedAuthorizationReason\n      }\n    },\n    statefulCoreRuntime({ name: 'google', initial, decodeState, inputInvalid })\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwJA,MAAM,kBAA8C;CAClD,GAAG;CACH,GAAG;CACH,GAAG;AACL;;;;;;AAOA,MAAa,uBACX,gBAAgB,IAAI,aAAa;;;;;;AAOnC,MAAa,mBAAmB;;;;;;;;AAWhC,MAAa,cAAc;;AAW3B,IAAa,6BAAb,cAAgD,KAAK,YAAY,4BAA4B,EAG1F;CACD,IAAa,UAAkB;EAC7B,OAAO,2BAA2B,KAAK,MAAM,IAAI,KAAK;CACxD;AACF;;AAiBA,MAAM,2BAA2B;;AAGjC,MAAM,wCACJ;AAEF,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,2BAA2B;CAAE;CAAO;AAAO,CAAC;;;;;;AAOlD,MAAa,qBAAqB,OAChC,UAAiC,CAAC,MACN;CAC5B,MAAM,UAAU,eAAe,QAAQ,QAAQ,CAAC,CAAC;CAEjD,IAAI,UAAU,SAAS,OAAO,GAC5B,MAAM,aAAa,QAAQ,OAAO;CAGpC,mBAAmB,QAAQ,QAAQ,0BAA0B,YAAY;CAEzE,MAAM,SAAS,QAAQ,UAAU,CAAC;CAElC,MAAM,MAAoB;EACxB,KAAK,QAAQ,cAAc,KAAK,IAAI;EACpC,QAAQ;GACN,kBAAkB,OAAO,qBAAqB;GAC9C,0BAA0B,OAAO,6BAA6B;GAC9D,wBAAwB,OAAO,2BAA2B;GAC1D,4BAA4B,OAAO,+BAA+B;GAClE,yBAAyB,OAAO,4BAA4B;GAC5D,uBAAuB,OAAO,0BAA0B;GACxD,sBAAsB,OAAO,yBAAyB;GACtD,qBAAqB,OAAO,wBAAwB;GACpD,wBAAwB,OAAO,2BAA2B;GAC1D,6BAA6B,OAAO,gCAAgC;GACpE,kBAAkB,OAAO,qBAAqB;GAC9C,uBAAuB,OAAO,0BAA0B;GACxD,qBAAqB,OAAO,wBAAwB;EACtD;EACA,4BAAY,IAAI,IAAI;EACpB,YAAY,EAAE,SAAS,EAAE;EACzB,6BAAa,IAAI,IAAI;CACvB;CAEA,OAAO,qBACL;EACE,QAAQ;EACR;EACA;EACA,WAAW;EACX,iBAAgB,WACd,OAAO,4BAA4B,MAAM,KAAA,IACrC,KAAA,IACA;EAEN,eAAe,CAAC;GAAE,MAAM;GAAgB,MAAM;EAAM,CAAC;EAErD,oBAAoB;GAClB,IAAI,WAAW,MAAM;GACrB,IAAI,WAAW,WAAW;EAC5B;EACA,qBAAqB,EAAE,YAAY,IAAI,WAAW,KAAK;EACvD,cAAa,WAAU;GACrB,UAAU,MAAM,SAAS;GACzB,QAAQ,MAAM,OAAO;GACrB,OAAO,MAAM,MAAM;EACrB;EACA;EACA,YAAY;GACV,cAAc;GACd,2BAA2B;EAC7B;CACF,GACA,oBAAoB;EAAE,MAAM;EAAU;EAAS;EAAa;CAAa,CAAC,CAC5E;AACF"}

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

@@ -0,0 +1,45 @@
+import { StatefulRoute } from "../stateful-emulator.mjs";
+import { LinkedInSearchEmulatorState } from "./state.mjs";
+
+//#region src/linkedin-search/api.d.ts
+/** Drill knobs (tests only): each makes the emulator disagree with one conformance claim. */
+type LinkedInSearchEmulatorDrills = {
+  /** A search with the default `numResults` (10) answers its results without `text`. */readonly defaultSearchWithoutText?: boolean; /** A search answers the query's seeded search with the most results, whatever `numResults`. */
+  readonly numResultsIgnored?: boolean; /** A profile lookup answers an empty JSON object. */
+  readonly profileAnswersEmptyObject?: boolean; /** An email lookup answers a JSON object without `email`. */
+  readonly emailAnswerOmitsEmail?: boolean; /** A rejected Exa key answers status 500 (with the recorded 401 body). */
+  readonly exaUnauthorizedAs5xx?: boolean; /** A rejected Enrich Layer key answers status 200 (with the recorded 401 body). */
+  readonly enrichLayerUnauthorizedAs2xx?: boolean; /** An absent profile answers status 200 (with the recorded 404 body). */
+  readonly absentProfileAs2xx?: boolean;
+};
+declare const linkedInSearchEmulatorDrillKnobs: ReadonlyArray<keyof LinkedInSearchEmulatorDrills>;
+type LinkedInSearchApiEnv = {
+  readonly drills: Readonly<Record<keyof LinkedInSearchEmulatorDrills, boolean>>;
+};
+/**
+ * The fixtures' error bodies, byte for byte (`JSON.stringify` keeps this key order): Exa's 401,
+ * Enrich Layer's 401 (the profile and the email lookup answer the same body), and Enrich Layer's
+ * not-found 404.
+ */
+declare const linkedInSearchEmulatorErrorBodies: {
+  readonly exaUnauthorized: {
+    readonly requestId: "synthetic-request-0003";
+    readonly error: "Invalid API key";
+  };
+  readonly enrichLayerUnauthorized: {
+    readonly code: 401;
+    readonly description: "Invalid API Key";
+    readonly name: "Unauthorized";
+  };
+  readonly profileNotFound: {
+    readonly code: 404;
+    readonly description: "Person profile does not exist";
+    readonly name: "Not Found";
+  };
+};
+type Route = StatefulRoute<LinkedInSearchEmulatorState, LinkedInSearchApiEnv>;
+/** Every emulated route, in manifest order. */
+declare const linkedInSearchApiRoutes: ReadonlyArray<Route>;
+//#endregion
+export { LinkedInSearchApiEnv, LinkedInSearchEmulatorDrills, linkedInSearchApiRoutes, linkedInSearchEmulatorDrillKnobs, linkedInSearchEmulatorErrorBodies };
+//# sourceMappingURL=api.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/linkedin-search/api.ts"],"mappings":";;;;;KA2CY,4BAAA;EAAA,+FAED,wBAAA;WAEA,iBAAA,YAFA;EAAA,SAIA,yBAAA;EAAA,SAEA,qBAAA,YAEA;EAAA,SAAA,oBAAA,YAIA;EAAA,SAFA,4BAAA,YAEkB;EAAA,SAAlB,kBAAA;AAAA;AAAA,cAGE,gCAAA,EAAkC,aAAa,OAAO,4BAAA;AAAA,KAUvD,oBAAA;EAAA,SACD,MAAA,EAAQ,QAAA,CAAS,MAAA,OAAa,4BAAA;AAAA;;;;;;cAQ5B,iCAAA;EAAA;;;;;;;;;;;;;;;KAMR,KAAA,GAAQ,aAAA,CAAc,2BAAA,EAA6B,oBAAA;;cAqR3C,uBAAA,EAAyB,aAAa,CAAC,KAAA"}

package/dist/linkedin-search/api.mjs

@@ -0,0 +1,181 @@
+import { exactBodyKeys, exactQuery, integerIn, isNotEmulated, notEmulated, statefulRoute } from "../stateful-emulator.mjs";
+import { linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorExaOrigin, linkedInSearchProfileUrlPattern, linkedInSearchQueryPattern } from "./state.mjs";
+import { Predicate } from "effect";
+//#region src/linkedin-search/api.ts
+/**
+* LinkedIn search emulator API: the route table (evidence, request-shape checks, and state-reading
+* plans), the fixture error bodies, and answer rendering (internal; re-exported by
+* `src/linkedin-search.ts`).
+*
+* Only the routes the seven LinkedIn search conformance cases send are emulated, each on its
+* recorded origin: the Exa people search (`POST /search` on `https://api.exa.ai`) and the Enrich
+* Layer profile and email lookups (`GET /api/v2/profile` and `GET /api/v2/profile/email` on
+* `https://enrichlayer.com`). Every route is a read: a plan reads the state and answers a fixture's
+* response or refuses (400 not-emulated, no fault used up); no commit writes.
+*
+* @experimental
+*/
+/** Content type of every answer, as the fixtures record it. */
+const contentType = "application/json";
+const linkedInSearchEmulatorDrillKnobs = [
+	"defaultSearchWithoutText",
+	"numResultsIgnored",
+	"profileAnswersEmptyObject",
+	"emailAnswerOmitsEmail",
+	"exaUnauthorizedAs5xx",
+	"enrichLayerUnauthorizedAs2xx",
+	"absentProfileAs2xx"
+];
+/**
+* The fixtures' error bodies, byte for byte (`JSON.stringify` keeps this key order): Exa's 401,
+* Enrich Layer's 401 (the profile and the email lookup answer the same body), and Enrich Layer's
+* not-found 404.
+*/
+const linkedInSearchEmulatorErrorBodies = {
+	exaUnauthorized: {
+		requestId: "synthetic-request-0003",
+		error: "Invalid API key"
+	},
+	enrichLayerUnauthorized: {
+		code: 401,
+		description: "Invalid API Key",
+		name: "Unauthorized"
+	},
+	profileNotFound: {
+		code: 404,
+		description: "Person profile does not exist",
+		name: "Not Found"
+	}
+};
+const peopleResultsCase = "linkedin-search.search.people-results";
+const numResultsLimitCase = "linkedin-search.search.num-results-limit";
+const profileCase = "linkedin-search.profile.get-profile";
+const emailCase = "linkedin-search.email.lookup-answer";
+const exaUnauthorizedCase = "linkedin-search.errors.exa-unauthorized";
+const enrichLayerUnauthorizedCase = "linkedin-search.errors.enrich-layer-unauthorized";
+const profileNotFoundCase = "linkedin-search.errors.profile-not-found";
+const evidence = (method, path, origin, caseIds) => ({
+	method,
+	path,
+	kind: "connector",
+	write: false,
+	caseIds,
+	evidence: "unverified",
+	origin,
+	params: {}
+});
+const json = (status, body) => new Response(JSON.stringify(body), {
+	status,
+	headers: { "content-type": contentType }
+});
+/** A read-only commit. */
+const answer = (response) => () => response();
+/** Whether the request's per-origin bearer digest is one a seed marks as rejected. */
+const rejected = (digests, digest) => digest !== void 0 && digests.includes(digest);
+/** The connector's default `numResults` (the people-results fixture's). */
+const defaultNumResults = 10;
+/** The result fields, in the fixtures' key order. */
+const resultKeys = [
+	"title",
+	"url",
+	"author",
+	"publishedDate",
+	"text"
+];
+const renderResult = (result) => {
+	const rendered = {};
+	for (const key of resultKeys) {
+		const value = result[key];
+		if (value !== void 0) rendered[key] = value;
+	}
+	return rendered;
+};
+/** The search the state answers for the input, or `undefined` (drills aside: the exact one). */
+const searchFor = (state, input, env) => {
+	const exact = state.searches.find((search) => search.query === input.query && search.numResults === input.numResults);
+	if (exact === void 0 || !env.drills.numResultsIgnored) return exact;
+	return state.searches.filter((search) => search.query === input.query).reduce((widest, search) => search.results.length > widest.results.length ? search : widest);
+};
+const search = statefulRoute({ ...evidence("POST", "/search", linkedInSearchEmulatorExaOrigin, [
+	peopleResultsCase,
+	numResultsLimitCase,
+	exaUnauthorizedCase
+]) }, "json", (request) => {
+	const query = exactQuery(request, [], [], { rawNames: true });
+	if (isNotEmulated(query)) return query;
+	const body = exactBodyKeys(request.json, "the search body", [
+		"query",
+		"category",
+		"numResults",
+		"type",
+		"contents"
+	]);
+	if (isNotEmulated(body)) return body;
+	const text = body.query;
+	if (!Predicate.isString(text) || !linkedInSearchQueryPattern.test(text) || text.length > 500) return notEmulated("query must be one trimmed, non-empty line of at most 500 characters");
+	if (body.category !== "people") return notEmulated("category other than people is not emulated");
+	if (body.type !== "auto") return notEmulated("type other than auto is not emulated");
+	const contents = exactBodyKeys(body.contents, "contents", ["text"]);
+	if (isNotEmulated(contents)) return contents;
+	if (contents.text !== true) return notEmulated("contents other than { text: true } is not emulated");
+	const numResults = integerIn(body.numResults, "numResults", 1, 100);
+	if (isNotEmulated(numResults)) return numResults;
+	return {
+		query: text,
+		numResults,
+		bearerDigest: request.bearerDigest
+	};
+}, (state, input, { env }) => {
+	if (rejected(state.exaRejectedKeyDigests, input.bearerDigest)) return answer(() => json(env.drills.exaUnauthorizedAs5xx ? 500 : 401, linkedInSearchEmulatorErrorBodies.exaUnauthorized));
+	const found = searchFor(state, input, env);
+	if (found === void 0) return notEmulated("a search the state holds no answer for (this query and numResults) is not emulated");
+	return answer(() => json(200, { results: found.results.map((result) => {
+		const rendered = renderResult(result);
+		if (!env.drills.defaultSearchWithoutText || input.numResults !== defaultNumResults) return rendered;
+		const { text: _text, ...withoutText } = rendered;
+		return withoutText;
+	}) }));
+});
+/** The one `linkedin_profile_url` query parameter: a profile URL (decoded once). */
+const lookupInput = (request) => {
+	const query = exactQuery(request, ["linkedin_profile_url"], [], { rawNames: true });
+	if (isNotEmulated(query)) return query;
+	const url = query.linkedin_profile_url ?? "";
+	if (!linkedInSearchProfileUrlPattern.test(url) || url.length > 2048) return notEmulated("linkedin_profile_url must be a profile URL https://<host>/in/<slug>");
+	return {
+		url,
+		bearerDigest: request.bearerDigest
+	};
+};
+const profileHeld = (state, url) => state.profiles.find((profile) => profile.url === url);
+/** The Enrich Layer unauthorized fixture's 401 (both lookups answer it). */
+const enrichLayerUnauthorized = (env) => answer(() => json(env.drills.enrichLayerUnauthorizedAs2xx ? 200 : 401, linkedInSearchEmulatorErrorBodies.enrichLayerUnauthorized));
+/** Every emulated route, in manifest order. */
+const linkedInSearchApiRoutes = [
+	search,
+	statefulRoute(evidence("GET", "/api/v2/profile", linkedInSearchEmulatorEnrichLayerOrigin, [
+		profileCase,
+		enrichLayerUnauthorizedCase,
+		profileNotFoundCase
+	]), "none", lookupInput, (state, input, { env }) => {
+		if (rejected(state.enrichLayerRejectedKeyDigests, input.bearerDigest)) return enrichLayerUnauthorized(env);
+		const held = profileHeld(state, input.url);
+		if (held !== void 0) return answer(() => json(200, env.drills.profileAnswersEmptyObject ? {} : {
+			public_identifier: held.publicIdentifier,
+			full_name: held.fullName,
+			headline: held.headline
+		}));
+		if (state.absentProfileUrls.includes(input.url)) return answer(() => json(env.drills.absentProfileAs2xx ? 200 : 404, linkedInSearchEmulatorErrorBodies.profileNotFound));
+		return notEmulated("a profile URL the state holds neither as a profile nor as absent is not emulated");
+	}),
+	statefulRoute(evidence("GET", "/api/v2/profile/email", linkedInSearchEmulatorEnrichLayerOrigin, [emailCase, enrichLayerUnauthorizedCase]), "none", lookupInput, (state, input, { env }) => {
+		if (rejected(state.enrichLayerRejectedKeyDigests, input.bearerDigest)) return enrichLayerUnauthorized(env);
+		const address = profileHeld(state, input.url)?.email;
+		if (address === void 0) return notEmulated("an email lookup of a profile the state holds no email answer for is not emulated");
+		return answer(() => json(200, env.drills.emailAnswerOmitsEmail ? {} : { email: address }));
+	})
+];
+//#endregion
+export { linkedInSearchApiRoutes, linkedInSearchEmulatorDrillKnobs, linkedInSearchEmulatorErrorBodies };
+
+//# sourceMappingURL=api.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.mjs","names":[],"sources":["../../src/linkedin-search/api.ts"],"sourcesContent":["/**\n * LinkedIn search emulator API: the route table (evidence, request-shape checks, and state-reading\n * plans), the fixture error bodies, and answer rendering (internal; re-exported by\n * `src/linkedin-search.ts`).\n *\n * Only the routes the seven LinkedIn search conformance cases send are emulated, each on its\n * recorded origin: the Exa people search (`POST /search` on `https://api.exa.ai`) and the Enrich\n * Layer profile and email lookups (`GET /api/v2/profile` and `GET /api/v2/profile/email` on\n * `https://enrichlayer.com`). Every route is a read: a plan reads the state and answers a fixture's\n * response or refuses (400 not-emulated, no fault used up); no commit writes.\n *\n * @experimental\n */\nimport { Predicate } from 'effect'\nimport type * as Schema from 'effect/Schema'\nimport {\n  exactBodyKeys,\n  exactQuery,\n  integerIn,\n  isNotEmulated,\n  notEmulated,\n  statefulRoute,\n  type Commit,\n  type EmulatedRequest,\n  type NotEmulated,\n  type StatefulRoute\n} from '../stateful-emulator.ts'\nimport {\n  linkedInSearchEmulatorEnrichLayerOrigin,\n  linkedInSearchEmulatorExaOrigin,\n  linkedInSearchMaxNumResults,\n  linkedInSearchProfileUrlPattern,\n  linkedInSearchQueryPattern,\n  type LinkedInSearchEmulatorProfile,\n  type LinkedInSearchEmulatorResult,\n  type LinkedInSearchEmulatorSearch,\n  type LinkedInSearchEmulatorState\n} from './state.ts'\n\n/** Content type of every answer, as the fixtures record it. */\nconst contentType = 'application/json'\n\n/** Drill knobs (tests only): each makes the emulator disagree with one conformance claim. */\nexport type LinkedInSearchEmulatorDrills = {\n  /** A search with the default `numResults` (10) answers its results without `text`. */\n  readonly defaultSearchWithoutText?: boolean\n  /** A search answers the query's seeded search with the most results, whatever `numResults`. */\n  readonly numResultsIgnored?: boolean\n  /** A profile lookup answers an empty JSON object. */\n  readonly profileAnswersEmptyObject?: boolean\n  /** An email lookup answers a JSON object without `email`. */\n  readonly emailAnswerOmitsEmail?: boolean\n  /** A rejected Exa key answers status 500 (with the recorded 401 body). */\n  readonly exaUnauthorizedAs5xx?: boolean\n  /** A rejected Enrich Layer key answers status 200 (with the recorded 401 body). */\n  readonly enrichLayerUnauthorizedAs2xx?: boolean\n  /** An absent profile answers status 200 (with the recorded 404 body). */\n  readonly absentProfileAs2xx?: boolean\n}\n\nexport const linkedInSearchEmulatorDrillKnobs: ReadonlyArray<keyof LinkedInSearchEmulatorDrills> = [\n  'defaultSearchWithoutText',\n  'numResultsIgnored',\n  'profileAnswersEmptyObject',\n  'emailAnswerOmitsEmail',\n  'exaUnauthorizedAs5xx',\n  'enrichLayerUnauthorizedAs2xx',\n  'absentProfileAs2xx'\n]\n\nexport type LinkedInSearchApiEnv = {\n  readonly drills: Readonly<Record<keyof LinkedInSearchEmulatorDrills, boolean>>\n}\n\n/**\n * The fixtures' error bodies, byte for byte (`JSON.stringify` keeps this key order): Exa's 401,\n * Enrich Layer's 401 (the profile and the email lookup answer the same body), and Enrich Layer's\n * not-found 404.\n */\nexport const linkedInSearchEmulatorErrorBodies = {\n  exaUnauthorized: { requestId: 'synthetic-request-0003', error: 'Invalid API key' },\n  enrichLayerUnauthorized: { code: 401, description: 'Invalid API Key', name: 'Unauthorized' },\n  profileNotFound: { code: 404, description: 'Person profile does not exist', name: 'Not Found' }\n} as const satisfies Readonly<Record<string, Schema.Json>>\n\ntype Route = StatefulRoute<LinkedInSearchEmulatorState, LinkedInSearchApiEnv>\n\nconst peopleResultsCase = 'linkedin-search.search.people-results'\n\nconst numResultsLimitCase = 'linkedin-search.search.num-results-limit'\n\nconst profileCase = 'linkedin-search.profile.get-profile'\n\nconst emailCase = 'linkedin-search.email.lookup-answer'\n\nconst exaUnauthorizedCase = 'linkedin-search.errors.exa-unauthorized'\n\nconst enrichLayerUnauthorizedCase = 'linkedin-search.errors.enrich-layer-unauthorized'\n\nconst profileNotFoundCase = 'linkedin-search.errors.profile-not-found'\n\nconst evidence = (\n  method: string,\n  path: string,\n  origin: string,\n  caseIds: ReadonlyArray<string>\n) => ({\n  method,\n  path,\n  kind: 'connector' as const,\n  write: false,\n  caseIds,\n  evidence: 'unverified' as const,\n  origin,\n  // No route has a path parameter: every raw path is matched exactly.\n  params: {}\n})\n\nconst json = (status: number, body: Schema.Json): Response =>\n  new Response(JSON.stringify(body), { status, headers: { 'content-type': contentType } })\n\n/** A read-only commit. */\nconst answer =\n  (response: () => Response): Commit =>\n  () =>\n    response()\n\n/** Whether the request's per-origin bearer digest is one a seed marks as rejected. */\nconst rejected = (digests: ReadonlyArray<string>, digest: string | undefined): boolean =>\n  digest !== undefined && digests.includes(digest)\n\n// Exa people search.\n\ntype SearchInput = {\n  readonly query: string\n  readonly numResults: number\n  readonly bearerDigest: string | undefined\n}\n\n/** The connector's default `numResults` (the people-results fixture's). */\nconst defaultNumResults = 10\n\n/** The result fields, in the fixtures' key order. */\nconst resultKeys = ['title', 'url', 'author', 'publishedDate', 'text'] as const\n\nconst renderResult = (result: LinkedInSearchEmulatorResult): Schema.JsonObject => {\n  const rendered: Record<string, string> = {}\n\n  for (const key of resultKeys) {\n    const value = result[key]\n\n    if (value !== undefined) rendered[key] = value\n  }\n\n  return rendered\n}\n\n/** The search the state answers for the input, or `undefined` (drills aside: the exact one). */\nconst searchFor = (\n  state: LinkedInSearchEmulatorState,\n  input: SearchInput,\n  env: LinkedInSearchApiEnv\n): LinkedInSearchEmulatorSearch | undefined => {\n  const exact = state.searches.find(\n    search => search.query === input.query && search.numResults === input.numResults\n  )\n\n  if (exact === undefined || !env.drills.numResultsIgnored) return exact\n\n  // The drill: the query's widest seeded answer (the first of the widest), whatever was asked.\n  return state.searches\n    .filter(search => search.query === input.query)\n    .reduce((widest, search) => (search.results.length > widest.results.length ? search : widest))\n}\n\nconst search: Route = statefulRoute(\n  {\n    ...evidence('POST', '/search', linkedInSearchEmulatorExaOrigin, [\n      peopleResultsCase,\n      numResultsLimitCase,\n      exaUnauthorizedCase\n    ])\n  },\n  'json',\n  (request): SearchInput | NotEmulated => {\n    const query = exactQuery(request, [], [], { rawNames: true })\n\n    if (isNotEmulated(query)) return query\n\n    const body = exactBodyKeys(request.json, 'the search body', [\n      'query',\n      'category',\n      'numResults',\n      'type',\n      'contents'\n    ])\n\n    if (isNotEmulated(body)) return body\n\n    const text = body.query\n\n    if (!Predicate.isString(text) || !linkedInSearchQueryPattern.test(text) || text.length > 500) {\n      return notEmulated('query must be one trimmed, non-empty line of at most 500 characters')\n    }\n\n    if (body.category !== 'people') return notEmulated('category other than people is not emulated')\n\n    if (body.type !== 'auto') return notEmulated('type other than auto is not emulated')\n\n    const contents = exactBodyKeys(body.contents, 'contents', ['text'])\n\n    if (isNotEmulated(contents)) return contents\n\n    if (contents.text !== true)\n      return notEmulated('contents other than { text: true } is not emulated')\n\n    const numResults = integerIn(body.numResults, 'numResults', 1, linkedInSearchMaxNumResults)\n\n    if (isNotEmulated(numResults)) return numResults\n\n    return { query: text, numResults, bearerDigest: request.bearerDigest }\n  },\n  (state, input, { env }) => {\n    if (rejected(state.exaRejectedKeyDigests, input.bearerDigest)) {\n      // The Exa unauthorized fixture's 401, whatever the (well-formed) search.\n      return answer(() =>\n        json(\n          env.drills.exaUnauthorizedAs5xx ? 500 : 401,\n          linkedInSearchEmulatorErrorBodies.exaUnauthorized\n        )\n      )\n    }\n\n    const found = searchFor(state, input, env)\n\n    if (found === undefined) {\n      return notEmulated(\n        'a search the state holds no answer for (this query and numResults) is not emulated'\n      )\n    }\n\n    return answer(() =>\n      json(200, {\n        results: found.results.map(result => {\n          const rendered = renderResult(result)\n\n          if (!env.drills.defaultSearchWithoutText || input.numResults !== defaultNumResults) {\n            return rendered\n          }\n\n          const { text: _text, ...withoutText } = rendered\n\n          return withoutText\n        })\n      })\n    )\n  }\n)\n\n// Enrich Layer lookups.\n\ntype LookupInput = { readonly url: string; readonly bearerDigest: string | undefined }\n\n/** The one `linkedin_profile_url` query parameter: a profile URL (decoded once). */\nconst lookupInput = (request: EmulatedRequest): LookupInput | NotEmulated => {\n  const query = exactQuery(request, ['linkedin_profile_url'], [], { rawNames: true })\n\n  if (isNotEmulated(query)) return query\n\n  const url = query.linkedin_profile_url ?? ''\n\n  if (!linkedInSearchProfileUrlPattern.test(url) || url.length > 2048) {\n    return notEmulated('linkedin_profile_url must be a profile URL https://<host>/in/<slug>')\n  }\n\n  return { url, bearerDigest: request.bearerDigest }\n}\n\nconst profileHeld = (\n  state: LinkedInSearchEmulatorState,\n  url: string\n): LinkedInSearchEmulatorProfile | undefined => state.profiles.find(profile => profile.url === url)\n\n/** The Enrich Layer unauthorized fixture's 401 (both lookups answer it). */\nconst enrichLayerUnauthorized = (env: LinkedInSearchApiEnv): Commit =>\n  answer(() =>\n    json(\n      env.drills.enrichLayerUnauthorizedAs2xx ? 200 : 401,\n      linkedInSearchEmulatorErrorBodies.enrichLayerUnauthorized\n    )\n  )\n\nconst profile: Route = statefulRoute(\n  evidence('GET', '/api/v2/profile', linkedInSearchEmulatorEnrichLayerOrigin, [\n    profileCase,\n    enrichLayerUnauthorizedCase,\n    profileNotFoundCase\n  ]),\n  'none',\n  lookupInput,\n  (state, input, { env }) => {\n    if (rejected(state.enrichLayerRejectedKeyDigests, input.bearerDigest)) {\n      return enrichLayerUnauthorized(env)\n    }\n\n    const held = profileHeld(state, input.url)\n\n    if (held !== undefined) {\n      return answer(() =>\n        json(\n          200,\n          env.drills.profileAnswersEmptyObject\n            ? {}\n            : {\n                public_identifier: held.publicIdentifier,\n                full_name: held.fullName,\n                headline: held.headline\n              }\n        )\n      )\n    }\n\n    if (state.absentProfileUrls.includes(input.url)) {\n      return answer(() =>\n        json(\n          env.drills.absentProfileAs2xx ? 200 : 404,\n          linkedInSearchEmulatorErrorBodies.profileNotFound\n        )\n      )\n    }\n\n    return notEmulated(\n      'a profile URL the state holds neither as a profile nor as absent is not emulated'\n    )\n  }\n)\n\nconst email: Route = statefulRoute(\n  evidence('GET', '/api/v2/profile/email', linkedInSearchEmulatorEnrichLayerOrigin, [\n    emailCase,\n    enrichLayerUnauthorizedCase\n  ]),\n  'none',\n  lookupInput,\n  (state, input, { env }) => {\n    if (rejected(state.enrichLayerRejectedKeyDigests, input.bearerDigest)) {\n      return enrichLayerUnauthorized(env)\n    }\n\n    const address = profileHeld(state, input.url)?.email\n\n    if (address === undefined) {\n      return notEmulated(\n        'an email lookup of a profile the state holds no email answer for is not emulated'\n      )\n    }\n\n    return answer(() => json(200, env.drills.emailAnswerOmitsEmail ? {} : { email: address }))\n  }\n)\n\n/** Every emulated route, in manifest order. */\nexport const linkedInSearchApiRoutes: ReadonlyArray<Route> = [search, profile, email]\n"],"mappings":"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"}

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

@@ -0,0 +1,123 @@
+import * as Schema from "effect/Schema";
+
+//#region src/linkedin-search/state.d.ts
+/** The origin every Exa fixture records; another origin is not emulated. */
+declare const linkedInSearchEmulatorExaOrigin = "https://api.exa.ai";
+/** The origin every Enrich Layer fixture records (its API base is `/api/v2`). */
+declare 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.
+ */
+declare const linkedInSearchKeyDigest: (key: string, origin: string) => string;
+/** A search query as the cases seed it: trimmed, non-empty, one line, at most 500 characters. */
+declare const linkedInSearchQueryPattern: RegExp;
+/** The profile URL form the emulator takes: `https://<host>/in/<slug>`. */
+declare const linkedInSearchProfileUrlPattern: RegExp;
+/** The largest `numResults` the emulator takes. */
+declare const linkedInSearchMaxNumResults = 100;
+/** One Exa result, in the fixtures' fields (each a string, or absent; never null). */
+declare const LinkedInSearchEmulatorResult: Schema.Struct<{
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly url: Schema.optionalKey<Schema.String>;
+  readonly author: Schema.optionalKey<Schema.String>;
+  readonly publishedDate: Schema.optionalKey<Schema.String>;
+  readonly text: Schema.optionalKey<Schema.String>;
+}>;
+type LinkedInSearchEmulatorResult = typeof LinkedInSearchEmulatorResult.Type;
+/**
+ * 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).
+ */
+declare const LinkedInSearchEmulatorSearch: Schema.Struct<{
+  readonly query: Schema.String;
+  readonly numResults: Schema.Int;
+  readonly results: Schema.$Array<Schema.Struct<{
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly url: Schema.optionalKey<Schema.String>;
+    readonly author: Schema.optionalKey<Schema.String>;
+    readonly publishedDate: Schema.optionalKey<Schema.String>;
+    readonly text: Schema.optionalKey<Schema.String>;
+  }>>;
+}>;
+type LinkedInSearchEmulatorSearch = typeof LinkedInSearchEmulatorSearch.Type;
+/**
+ * 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).
+ */
+declare const LinkedInSearchEmulatorProfile: Schema.Struct<{
+  readonly url: Schema.String;
+  readonly publicIdentifier: Schema.String;
+  readonly fullName: Schema.String;
+  readonly headline: Schema.String;
+  readonly email: Schema.optionalKey<Schema.String>;
+}>;
+type LinkedInSearchEmulatorProfile = typeof LinkedInSearchEmulatorProfile.Type;
+/** The whole emulator state (JSON-compatible; what `snapshot()` returns). */
+declare const LinkedInSearchEmulatorStateSchema: Schema.Struct<{
+  /** Digests (for the Exa origin) of the keys Exa answers with the recorded 401. */readonly exaRejectedKeyDigests: Schema.$Array<Schema.String>;
+  readonly searches: Schema.$Array<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly numResults: Schema.Int;
+    readonly results: Schema.$Array<Schema.Struct<{
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly url: Schema.optionalKey<Schema.String>;
+      readonly author: Schema.optionalKey<Schema.String>;
+      readonly publishedDate: Schema.optionalKey<Schema.String>;
+      readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+  }>>; /** Digests (for the Enrich Layer origin) of the keys Enrich Layer answers with the 401. */
+  readonly enrichLayerRejectedKeyDigests: Schema.$Array<Schema.String>;
+  readonly profiles: Schema.$Array<Schema.Struct<{
+    readonly url: Schema.String;
+    readonly publicIdentifier: Schema.String;
+    readonly fullName: Schema.String;
+    readonly headline: Schema.String;
+    readonly email: Schema.optionalKey<Schema.String>;
+  }>>; /** Profile URLs that name no profile: their profile lookup answers the recorded 404. */
+  readonly absentProfileUrls: Schema.$Array<Schema.String>;
+}>;
+type LinkedInSearchEmulatorState = typeof LinkedInSearchEmulatorStateSchema.Type;
+/**
+ * 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.
+ */
+declare const LinkedInSearchEmulatorSeed: Schema.Struct<{
+  readonly exaRejectedKeys: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly searches: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly numResults: Schema.Int;
+    readonly results: Schema.$Array<Schema.Struct<{
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly url: Schema.optionalKey<Schema.String>;
+      readonly author: Schema.optionalKey<Schema.String>;
+      readonly publishedDate: Schema.optionalKey<Schema.String>;
+      readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+  }>>>;
+  readonly enrichLayerRejectedKeys: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly profiles: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly url: Schema.String;
+    readonly publicIdentifier: Schema.String;
+    readonly fullName: Schema.String;
+    readonly headline: Schema.String;
+    readonly email: Schema.optionalKey<Schema.String>;
+  }>>>;
+  readonly absentProfileUrls: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+type LinkedInSearchEmulatorSeed = typeof LinkedInSearchEmulatorSeed.Type;
+/** The synthetic invalid keys the unauthorized cases send (never account data). */
+declare const linkedInSearchEmulatorDefaultRejectedKeys: {
+  readonly exa: readonly ["yolk-conformance-invalid-exa-key"];
+  readonly enrichLayer: readonly ["yolk-conformance-invalid-enrich-layer-key"];
+};
+/**
+ * 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).
+ */
+declare const buildSeedState: (input: unknown) => LinkedInSearchEmulatorState | string;
+/** Decode a full state (a restored snapshot); a string is the reason it is invalid (constant). */
+declare const decodeState: (input: unknown) => LinkedInSearchEmulatorState | string;
+//#endregion
+export { LinkedInSearchEmulatorProfile, LinkedInSearchEmulatorResult, LinkedInSearchEmulatorSearch, LinkedInSearchEmulatorSeed, LinkedInSearchEmulatorState, LinkedInSearchEmulatorStateSchema, buildSeedState, decodeState, linkedInSearchEmulatorDefaultRejectedKeys, linkedInSearchEmulatorEnrichLayerOrigin, linkedInSearchEmulatorExaOrigin, linkedInSearchKeyDigest, linkedInSearchMaxNumResults, linkedInSearchProfileUrlPattern, linkedInSearchQueryPattern };
+//# sourceMappingURL=state.d.mts.map