@yolk-sdk/emulators 0.1.0-canary.96

package/dist/github.d.mts

@@ -0,0 +1,77 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulCoverage, StatefulEmulatorApi, StatefulFault, StatefulFaultMatch, StatefulFaultState, StatefulInputKind, StatefulLedgerEntry } from "./stateful-emulator.mjs";
+import { GithubEmulatorComment, GithubEmulatorFile, GithubEmulatorIssue, GithubEmulatorLabel, GithubEmulatorProfile, GithubEmulatorRepository, GithubEmulatorSeed, GithubEmulatorSeedIssue, GithubEmulatorState, GithubEmulatorStateSchema, GithubEmulatorUser } from "./github/state.mjs";
+import { GithubEmulatorDrills, githubEmulatorAccept, githubEmulatorApiVersion, githubEmulatorErrorBodies, githubEmulatorOrigin } from "./github/api.mjs";
+
+//#region src/github.d.ts
+/**
+ * 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).
+ */
+declare const githubEmulatorRoutes: 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 GithubFaultMatch: 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 GithubFaultMatch = typeof StatefulFaultMatch.Type;
+/**
+ * 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.
+ */
+declare const GithubFault: 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 GithubFault = StatefulFault;
+type GithubFaultState = StatefulFaultState;
+type GithubLedgerEntry = StatefulLedgerEntry;
+type GithubCoverage = StatefulCoverage;
+declare const GithubEmulatorInputInvalid_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: "GithubEmulatorInputInvalid";
+} & Readonly<A>;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+declare class GithubEmulatorInputInvalid extends GithubEmulatorInputInvalid_base<{
+  readonly input: StatefulInputKind;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type GithubEmulatorOptions = {
+  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */readonly seed?: GithubEmulatorSeed;
+  /**
+   * Clock in epoch milliseconds (created issue and comment times, close times). Defaults to
+   * `Date.now`.
+   */
+  readonly now?: () => number; /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */
+  readonly drills?: GithubEmulatorDrills;
+};
+type GithubEmulator = StatefulEmulatorApi<GithubEmulatorState, GithubEmulatorSeed>;
+/**
+ * Create a stateful GitHub emulator on the `@emulators/core` custom runtime. Each call has its own
+ * state, ledger, and faults. Rejects with `GithubEmulatorInputInvalid` for an invalid seed or
+ * option. Every request needs `Accept: application/vnd.github+json` and
+ * `X-GitHub-Api-Version: 2026-03-10` (else not emulated). See `src/stateful-emulator.ts` for the
+ * request precedence.
+ */
+declare const makeGithubEmulator: (options?: GithubEmulatorOptions) => Promise<GithubEmulator>;
+//#endregion
+export { type EmulatorEvidence, type EmulatorRouteEvidence, GithubCoverage, GithubEmulator, GithubEmulatorComment, type GithubEmulatorDrills, GithubEmulatorFile, GithubEmulatorInputInvalid, GithubEmulatorIssue, GithubEmulatorLabel, GithubEmulatorOptions, GithubEmulatorProfile, GithubEmulatorRepository, GithubEmulatorSeed, GithubEmulatorSeedIssue, type GithubEmulatorState, GithubEmulatorStateSchema, GithubEmulatorUser, GithubFault, GithubFaultMatch, GithubFaultState, GithubLedgerEntry, emulatorEvidenceHeader, githubEmulatorAccept, githubEmulatorApiVersion, githubEmulatorErrorBodies, githubEmulatorOrigin, githubEmulatorRoutes, makeGithubEmulator };
+//# sourceMappingURL=github.d.mts.map

package/dist/github.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.mts","names":[],"sources":["../src/github.ts"],"mappings":";;;;;;;;AA0IsE;AAQtE;;cARa,oBAAA,EAAsB,aAAa,CAAC,qBAAA;;;;;;cAQpC,gBAAA,0BAAgB,MAAA;EAAA;;;;KAEjB,gBAAA,UAA0B,kBAAA,CAAmB,IAAI;;;AAA7D;;;;AAA6D;cAShD,WAAA,0BAAW,MAAA;EAAA;;;;;;;;;;;KAEZ,WAAA,GAAc,aAAa;AAAA,KAE3B,gBAAA,GAAmB,kBAAkB;AAAA,KAErC,iBAAA,GAAoB,mBAAmB;AAAA,KAEvC,cAAA,GAAiB,gBAAgB;AAAA,cAAA,+BAAA;;;;cAGhC,0BAAA,SAAmC,+BAAA;EAAA,SACrC,KAAA,EAAO,iBAAA;EAAA,SACP,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,qBAAA;sFAED,IAAA,GAAO,kBAAA;;;;;WAKP,GAAA;WAEA,MAAA,GAAS,oBAAoB;AAAA;AAAA,KAG5B,cAAA,GAAiB,mBAAA,CAAoB,mBAAA,EAAqB,kBAAA;;;AA9B/B;AAEvC;;;;cA+Ca,kBAAA,GACX,OAAA,GAAS,qBAAA,KACR,OAAA,CAAQ,cAAA"}

package/dist/github.mjs

@@ -0,0 +1,180 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, checkBooleanDrills, makeStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { GithubEmulatorComment, GithubEmulatorFile, GithubEmulatorIssue, GithubEmulatorLabel, GithubEmulatorProfile, GithubEmulatorRepository, GithubEmulatorSeed, GithubEmulatorSeedIssue, GithubEmulatorStateSchema, GithubEmulatorUser, buildSeedState, decodeState } from "./github/state.mjs";
+import { githubApiRoutes, githubEmulatorAccept, githubEmulatorApiVersion, githubEmulatorDrillKnobs, githubEmulatorErrorBodies, githubEmulatorOrigin } from "./github/api.mjs";
+import { Data, Predicate } from "effect";
+//#region src/github.ts
+/**
+* Stateful GitHub emulator (the REST routes of the GitHub conformance cases on
+* `https://api.github.com`, API version 2026-03-10), 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 bodies, and default seed are copied as data
+* from the synthetic GitHub conformance fixtures, and every route names the conformance cases it
+* follows in `githubEmulatorRoutes`. Only the routes those seven cases send are emulated. 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 the leftover lookup's
+* open-issue listing (`GET /repos/{owner}/{repo}/issues`, no fixture), so the read-only lookup
+* fails and the live runner prints its lookup-failed WARN. Every route answers only on the
+* recorded origin `https://api.github.com` (`fetchOn(origin)` serves it behind a loopback
+* rewrite).
+*
+* Fail closed: a request is recognised only when its raw path is exactly an emulated route shape
+* (every path parameter matches its raw pattern in full) under that route's method, and any
+* `Authorization` header is exactly `Bearer <token>` (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 bearer must match the RFC 6750
+* `b64token` syntax exactly (`^[A-Za-z0-9\-._~+/]+=*$`, at least 8 characters), start with a
+* character in `[G-Zg-z\-._~+/]` other than `n`, `r`, `t`, `u`, and hold at least one character
+* outside the JSON-number alphabet `[0-9.eE+-]` (every GitHub and Google token form does: `ghp_…`,
+* `github_pat_…`, `gho_…`, `ya29.…`). So no number's text can contain it; it holds no escape
+* introducer (`%`, `\`, `"`), so no escape starts inside it; and its first character is no hex
+* digit and no JSON escape letter, so no stray `%`, `\`, or partial escape to its left can complete
+* with it, and its characters always decode in place. An `Authorization` header with any other
+* value is unrecognisable. A recognised request that repeats the bearer value in its raw path, any
+* path segment, the raw query or any query key or value, any recorded header, or its body is
+* refused and ledgered with constant text only: a standard method, the path `/<unrecognised>`, its
+* route template, an empty query, no headers or body, and a constant reason
+* (`the query repeats the credential`, for example). Each part is checked through the closure of
+* two total, lexical transforms that cannot fail: a tolerant percent-decode (every `%XX` below
+* `%80` becomes its ASCII character; any other `%` sequence is left as it is) and a tolerant
+* JSON-unescape (in any text, whether or not it parses as JSON, `\uXXXX` below `\u0080` and `\"`,
+* `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, `\t` become their characters). Starting from each part's raw
+* text, either transform is applied to every text of the previous step, deduplicated, until no new
+* text appears (a fixpoint), and every text is checked for the bearer as a substring; both
+* transforms never lengthen a text and shorten it whenever they change it. So any depth of
+* percent-encoding or JSON escaping, in any order, is seen through in every part: the raw path and
+* each raw path segment, the raw query and each query key and value (already decoded once by
+* `URLSearchParams`), each recorded header, and the raw body. The work is capped at 64 rounds, 1024
+* distinct texts, or 8 Mi characters read by the transforms, whichever comes first; a part whose
+* closure hits a cap before its fixpoint counts as repeating the credential and is refused with the
+* same constant entry (uncertainty refuses, it never admits; so any part over 4 Mi characters is
+* always refused). Any other recognised request has the bearer value scrubbed from its ledgered
+* fields and every not-emulated reason (plan-time reasons included); its recorded query is keyed by
+* recorded key; a key recorded more than once lists its values in order (as a JSON array); and
+* recorded headers and query keys and values that start like JSON (`{`, `[`, `"`) are recorded
+* parsed with credential-named keys redacted at any depth, or as `<redacted>` when they do not
+* parse, whatever the header's declared format. Refusals never echo a request's own query or body
+* keys.
+*
+* Request-shape latitude (`/github`, 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` (so a legacy all-hex token is
+* refused), with at least one outside `[0-9.eE+-]`, that occurs nowhere else in the request (never
+* compared against anything, stored, or ledgered); extra request headers; JSON key order;
+* `content-type` media-type parameters; the order of query parameters; any non-empty issue title
+* and comment body, and any issue body text; any comment listing `since` of the form
+* `YYYY-MM-DDTHH:MM:SSZ`; any label listing `per_page` from 1 to 100, with no `page` or a `page`
+* from 2 to one past the last page; any issue search `q` that starts with the seeded
+* `repo:<owner>/<repo>` qualifier and whose query after it is longer than 256 characters (answered
+* the recorded 422); any issue number the repository has not reached (answered the recorded 404);
+* and any issue, comment, repository label, or file the state holds where a fixture has one, under
+* the per-route state rules. `Authorization` must be exactly `Bearer <token>` (that spelling, one
+* space), `Accept` `application/vnd.github+json`, and `X-GitHub-Api-Version` `2026-03-10`.
+* Everything else (other keys and values, query parameters, empty query components such as a bare
+* `?` or a stray `&`, another origin or repository, a repeated query key, an explicit `page=1`, and
+* a comment listing `per_page` other than 100) is not emulated.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeGithubEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+/**
+* 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).
+*/
+const githubEmulatorRoutes = githubApiRoutes.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 GithubFaultMatch = 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 GithubFault = StatefulFault;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+var GithubEmulatorInputInvalid = class extends Data.TaggedError("GithubEmulatorInputInvalid") {
+	get message() {
+		return `Invalid GitHub emulator ${this.input}: ${this.reason}`;
+	}
+};
+const inputInvalid = (input, reason) => new GithubEmulatorInputInvalid({
+	input,
+	reason
+});
+/** The constant reason of a request on no emulated route shape. */
+const githubUnrecognisedReason = "no emulated GitHub route for this method and path";
+/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */
+const githubUnrecognisedAuthorizationReason = "an unrecognisable Authorization header is not emulated";
+/**
+* Create a stateful GitHub emulator on the `@emulators/core` custom runtime. Each call has its own
+* state, ledger, and faults. Rejects with `GithubEmulatorInputInvalid` for an invalid seed or
+* option. Every request needs `Accept: application/vnd.github+json` and
+* `X-GitHub-Api-Version: 2026-03-10` (else not emulated). See `src/stateful-emulator.ts` for the
+* request precedence.
+*/
+const makeGithubEmulator = async (options = {}) => {
+	const initial = buildSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw inputInvalid("seed", initial);
+	checkBooleanDrills(options.drills, githubEmulatorDrillKnobs, inputInvalid);
+	const drills = options.drills ?? {};
+	return makeStatefulEmulator({
+		routes: githubApiRoutes,
+		env: {
+			now: options.now ?? (() => Date.now()),
+			drills: {
+				linkOmitsNext: drills.linkOmitsNext === true,
+				notFoundOmitsDocumentationUrl: drills.notFoundOmitsDocumentationUrl === true,
+				validationWithoutErrors: drills.validationWithoutErrors === true,
+				contentUnfolded: drills.contentUnfolded === true,
+				sinceExcludesEqual: drills.sinceExcludesEqual === true,
+				addAnswerOmitsLabel: drills.addAnswerOmitsLabel === true,
+				closeWithoutClosedAt: drills.closeWithoutClosedAt === true
+			}
+		},
+		initial,
+		buildSeed: buildSeedState,
+		requestProblem: (header) => {
+			if (header("accept") !== "application/vnd.github+json") return `Accept other than ${githubEmulatorAccept} is not emulated`;
+			return header("x-github-api-version") === "2026-03-10" ? void 0 : `X-GitHub-Api-Version other than ${githubEmulatorApiVersion} is not emulated`;
+		},
+		recordHeaders: [{
+			name: "accept",
+			json: false
+		}, {
+			name: "x-github-api-version",
+			json: false
+		}],
+		failClosed: {
+			unrecognised: githubUnrecognisedReason,
+			unrecognisedAuthorization: githubUnrecognisedAuthorizationReason
+		},
+		clearRuntime: () => void 0,
+		runtimeState: () => ({}),
+		seedSummary: (state) => ({
+			labels: state.labels.length,
+			issues: state.issues.length,
+			files: state.files.length
+		}),
+		inputInvalid
+	}, statefulCoreRuntime({
+		name: "github",
+		initial,
+		decodeState,
+		inputInvalid
+	}));
+};
+//#endregion
+export { GithubEmulatorComment, GithubEmulatorFile, GithubEmulatorInputInvalid, GithubEmulatorIssue, GithubEmulatorLabel, GithubEmulatorProfile, GithubEmulatorRepository, GithubEmulatorSeed, GithubEmulatorSeedIssue, GithubEmulatorStateSchema, GithubEmulatorUser, GithubFault, GithubFaultMatch, emulatorEvidenceHeader, githubEmulatorAccept, githubEmulatorApiVersion, githubEmulatorErrorBodies, githubEmulatorOrigin, githubEmulatorRoutes, makeGithubEmulator };
+
+//# sourceMappingURL=github.mjs.map

package/dist/github.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.mjs","names":[],"sources":["../src/github.ts"],"sourcesContent":["/**\n * Stateful GitHub emulator (the REST routes of the GitHub conformance cases on\n * `https://api.github.com`, API version 2026-03-10), built on the upstream `@emulators/core`\n * custom runtime, with a request ledger, status faults, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes, error bodies, and default seed are copied as data\n * from the synthetic GitHub conformance fixtures, and every route names the conformance cases it\n * follows in `githubEmulatorRoutes`. Only the routes those seven cases send are emulated. Response\n * behaviour comes only from the fixtures: anything they do not show answers one ledgered 400\n * not-emulated, writes nothing, and uses up no fault. That includes the leftover lookup's\n * open-issue listing (`GET /repos/{owner}/{repo}/issues`, no fixture), so the read-only lookup\n * fails and the live runner prints its lookup-failed WARN. Every route answers only on the\n * recorded origin `https://api.github.com` (`fetchOn(origin)` serves it behind a loopback\n * rewrite).\n *\n * Fail closed: a request is recognised only when its raw path is exactly an emulated route shape\n * (every path parameter matches its raw pattern in full) under that route's method, and any\n * `Authorization` header is exactly `Bearer <token>` (a recognisable bearer, below). Every other\n * request is ledgered and answered with constant text only (`/<unrecognised>`, a standard method or\n * `<other>`, an empty query, no body, a constant reason). The bearer value is never compared\n * against anything, stored, forwarded, or ledgered. A recognised bearer must match the RFC 6750\n * `b64token` syntax exactly (`^[A-Za-z0-9\\-._~+/]+=*$`, at least 8 characters), start with a\n * character in `[G-Zg-z\\-._~+/]` other than `n`, `r`, `t`, `u`, and hold at least one character\n * outside the JSON-number alphabet `[0-9.eE+-]` (every GitHub and Google token form does: `ghp_…`,\n * `github_pat_…`, `gho_…`, `ya29.…`). So no number's text can contain it; it holds no escape\n * introducer (`%`, `\\`, `\"`), so no escape starts inside it; and its first character is no hex\n * digit and no JSON escape letter, so no stray `%`, `\\`, or partial escape to its left can complete\n * with it, and its characters always decode in place. An `Authorization` header with any other\n * value is unrecognisable. A recognised request that repeats the bearer value in its raw path, any\n * path segment, the raw query or any query key or value, any recorded header, or its body is\n * refused and ledgered with constant text only: a standard method, the path `/<unrecognised>`, its\n * route template, an empty query, no headers or body, and a constant reason\n * (`the query repeats the credential`, for example). Each part is checked through the closure of\n * two total, lexical transforms that cannot fail: a tolerant percent-decode (every `%XX` below\n * `%80` becomes its ASCII character; any other `%` sequence is left as it is) and a tolerant\n * JSON-unescape (in any text, whether or not it parses as JSON, `\\uXXXX` below `\\u0080` and `\\\"`,\n * `\\\\`, `\\/`, `\\b`, `\\f`, `\\n`, `\\r`, `\\t` become their characters). Starting from each part's raw\n * text, either transform is applied to every text of the previous step, deduplicated, until no new\n * text appears (a fixpoint), and every text is checked for the bearer as a substring; both\n * transforms never lengthen a text and shorten it whenever they change it. So any depth of\n * percent-encoding or JSON escaping, in any order, is seen through in every part: the raw path and\n * each raw path segment, the raw query and each query key and value (already decoded once by\n * `URLSearchParams`), each recorded header, and the raw body. The work is capped at 64 rounds, 1024\n * distinct texts, or 8 Mi characters read by the transforms, whichever comes first; a part whose\n * closure hits a cap before its fixpoint counts as repeating the credential and is refused with the\n * same constant entry (uncertainty refuses, it never admits; so any part over 4 Mi characters is\n * always refused). Any other recognised request has the bearer value scrubbed from its ledgered\n * fields and every not-emulated reason (plan-time reasons included); its recorded query is keyed by\n * recorded key; a key recorded more than once lists its values in order (as a JSON array); and\n * recorded headers and query keys and values that start like JSON (`{`, `[`, `\"`) are recorded\n * parsed with credential-named keys redacted at any depth, or as `<redacted>` when they do not\n * parse, whatever the header's declared format. Refusals never echo a request's own query or body\n * keys.\n *\n * Request-shape latitude (`/github`, 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` (so a legacy all-hex token is\n * refused), with at least one outside `[0-9.eE+-]`, that occurs nowhere else in the request (never\n * compared against anything, stored, or ledgered); extra request headers; JSON key order;\n * `content-type` media-type parameters; the order of query parameters; any non-empty issue title\n * and comment body, and any issue body text; any comment listing `since` of the form\n * `YYYY-MM-DDTHH:MM:SSZ`; any label listing `per_page` from 1 to 100, with no `page` or a `page`\n * from 2 to one past the last page; any issue search `q` that starts with the seeded\n * `repo:<owner>/<repo>` qualifier and whose query after it is longer than 256 characters (answered\n * the recorded 422); any issue number the repository has not reached (answered the recorded 404);\n * and any issue, comment, repository label, or file the state holds where a fixture has one, under\n * the per-route state rules. `Authorization` must be exactly `Bearer <token>` (that spelling, one\n * space), `Accept` `application/vnd.github+json`, and `X-GitHub-Api-Version` `2026-03-10`.\n * Everything else (other keys and values, query parameters, empty query components such as a bare\n * `?` or a stray `&`, another origin or repository, a repeated query key, an explicit `page=1`, and\n * a comment listing `per_page` other than 100) is not emulated.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeGithubEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport {\n  githubApiRoutes,\n  githubEmulatorAccept,\n  githubEmulatorApiVersion,\n  githubEmulatorDrillKnobs,\n  type GithubApiEnv,\n  type GithubEmulatorDrills\n} from './github/api.ts'\nimport {\n  buildSeedState,\n  decodeState,\n  type GithubEmulatorSeed,\n  type GithubEmulatorState\n} from './github/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  githubEmulatorAccept,\n  githubEmulatorApiVersion,\n  githubEmulatorErrorBodies,\n  githubEmulatorOrigin,\n  type GithubEmulatorDrills\n} from './github/api.ts'\n\nexport {\n  GithubEmulatorComment,\n  GithubEmulatorFile,\n  GithubEmulatorIssue,\n  GithubEmulatorLabel,\n  GithubEmulatorProfile,\n  GithubEmulatorRepository,\n  GithubEmulatorSeed,\n  GithubEmulatorSeedIssue,\n  GithubEmulatorStateSchema,\n  GithubEmulatorUser,\n  type GithubEmulatorState\n} from './github/state.ts'\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).\n */\nexport const githubEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> =\n  githubApiRoutes.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 GithubFaultMatch = StatefulFaultMatch\n\nexport type GithubFaultMatch = 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 GithubFault = StatefulFault\n\nexport type GithubFault = StatefulFault\n\nexport type GithubFaultState = StatefulFaultState\n\nexport type GithubLedgerEntry = StatefulLedgerEntry\n\nexport type GithubCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */\nexport class GithubEmulatorInputInvalid extends Data.TaggedError('GithubEmulatorInputInvalid')<{\n  readonly input: StatefulInputKind\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid GitHub emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type GithubEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */\n  readonly seed?: GithubEmulatorSeed\n  /**\n   * Clock in epoch milliseconds (created issue and comment times, close times). Defaults to\n   * `Date.now`.\n   */\n  readonly now?: () => number\n  /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */\n  readonly drills?: GithubEmulatorDrills\n}\n\nexport type GithubEmulator = StatefulEmulatorApi<GithubEmulatorState, GithubEmulatorSeed>\n\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new GithubEmulatorInputInvalid({ input, reason })\n\n/** The constant reason of a request on no emulated route shape. */\nconst githubUnrecognisedReason = 'no emulated GitHub route for this method and path'\n\n/** The constant reason of a request whose `Authorization` header is not one recognisable bearer. */\nconst githubUnrecognisedAuthorizationReason =\n  'an unrecognisable Authorization header is not emulated'\n\n/**\n * Create a stateful GitHub emulator on the `@emulators/core` custom runtime. Each call has its own\n * state, ledger, and faults. Rejects with `GithubEmulatorInputInvalid` for an invalid seed or\n * option. Every request needs `Accept: application/vnd.github+json` and\n * `X-GitHub-Api-Version: 2026-03-10` (else not emulated). See `src/stateful-emulator.ts` for the\n * request precedence.\n */\nexport const makeGithubEmulator = async (\n  options: GithubEmulatorOptions = {}\n): Promise<GithubEmulator> => {\n  const initial = buildSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw inputInvalid('seed', initial)\n  }\n\n  checkBooleanDrills(options.drills, githubEmulatorDrillKnobs, inputInvalid)\n\n  const drills = options.drills ?? {}\n\n  const env: GithubApiEnv = {\n    now: options.now ?? (() => Date.now()),\n    drills: {\n      linkOmitsNext: drills.linkOmitsNext === true,\n      notFoundOmitsDocumentationUrl: drills.notFoundOmitsDocumentationUrl === true,\n      validationWithoutErrors: drills.validationWithoutErrors === true,\n      contentUnfolded: drills.contentUnfolded === true,\n      sinceExcludesEqual: drills.sinceExcludesEqual === true,\n      addAnswerOmitsLabel: drills.addAnswerOmitsLabel === true,\n      closeWithoutClosedAt: drills.closeWithoutClosedAt === true\n    }\n  }\n\n  return makeStatefulEmulator<GithubEmulatorState, GithubApiEnv, GithubEmulatorSeed>(\n    {\n      routes: githubApiRoutes,\n      env,\n      initial,\n      buildSeed: buildSeedState,\n      requestProblem: header => {\n        // The values every fixture sends.\n        if (header('accept') !== githubEmulatorAccept) {\n          return `Accept other than ${githubEmulatorAccept} is not emulated`\n        }\n\n        return header('x-github-api-version') === githubEmulatorApiVersion\n          ? undefined\n          : `X-GitHub-Api-Version other than ${githubEmulatorApiVersion} is not emulated`\n      },\n      recordHeaders: [\n        { name: 'accept', json: false },\n        { name: 'x-github-api-version', json: false }\n      ],\n      failClosed: {\n        unrecognised: githubUnrecognisedReason,\n        unrecognisedAuthorization: githubUnrecognisedAuthorizationReason\n      },\n      // No cursors: label pages are page numbers, as GitHub's are.\n      clearRuntime: () => undefined,\n      runtimeState: () => ({}),\n      seedSummary: state => ({\n        labels: state.labels.length,\n        issues: state.issues.length,\n        files: state.files.length\n      }),\n      inputInvalid\n    },\n    statefulCoreRuntime({ name: 'github', initial, decodeState, inputInvalid })\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0IA,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;AAgBA,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,2BAA2B;CAAE;CAAO;AAAO,CAAC;;AAGlD,MAAM,2BAA2B;;AAGjC,MAAM,wCACJ;;;;;;;;AASF,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,OAAO,qBACL;EACE,QAAQ;EACR,KAAA;GAfF,KAAK,QAAQ,cAAc,KAAK,IAAI;GACpC,QAAQ;IACN,eAAe,OAAO,kBAAkB;IACxC,+BAA+B,OAAO,kCAAkC;IACxE,yBAAyB,OAAO,4BAA4B;IAC5D,iBAAiB,OAAO,oBAAoB;IAC5C,oBAAoB,OAAO,uBAAuB;IAClD,qBAAqB,OAAO,wBAAwB;IACpD,sBAAsB,OAAO,yBAAyB;GACxD;EAMI;EACF;EACA,WAAW;EACX,iBAAgB,WAAU;GAExB,IAAI,OAAO,QAAQ,MAAA,+BACjB,OAAO,qBAAqB,qBAAqB;GAGnD,OAAO,OAAO,sBAAsB,MAAA,eAChC,KAAA,IACA,mCAAmC,yBAAyB;EAClE;EACA,eAAe,CACb;GAAE,MAAM;GAAU,MAAM;EAAM,GAC9B;GAAE,MAAM;GAAwB,MAAM;EAAM,CAC9C;EACA,YAAY;GACV,cAAc;GACd,2BAA2B;EAC7B;EAEA,oBAAoB,KAAA;EACpB,qBAAqB,CAAC;EACtB,cAAa,WAAU;GACrB,QAAQ,MAAM,OAAO;GACrB,QAAQ,MAAM,OAAO;GACrB,OAAO,MAAM,MAAM;EACrB;EACA;CACF,GACA,oBAAoB;EAAE,MAAM;EAAU;EAAS;EAAa;CAAa,CAAC,CAC5E;AACF"}

package/dist/google/calendar.d.mts

@@ -0,0 +1,10 @@
+import { GoogleRoute } from "./shared.mjs";
+
+//#region src/google/calendar.d.ts
+/** Path of the events collection of `{calendarId}`. */
+declare const calendarEventsPath = "/calendar/v3/calendars/{calendarId}/events";
+/** The Calendar routes, in manifest order. */
+declare const calendarRoutes: ReadonlyArray<GoogleRoute>;
+//#endregion
+export { calendarEventsPath, calendarRoutes };
+//# sourceMappingURL=calendar.d.mts.map

package/dist/google/calendar.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.d.mts","names":[],"sources":["../../src/google/calendar.ts"],"mappings":";;;;cAgDa,kBAAA;AAAb;AAAA,cA+aa,cAAA,EAAgB,aAAa,CAAC,WAAA"}

package/dist/google/calendar.mjs

@@ -0,0 +1,252 @@
+import { exactBodyKeys, exactQuery, isNotEmulated, notEmulated, statefulRoute } from "../stateful-emulator.mjs";
+import { answer, evidence, googleEmulatorApisOrigin, googleErrorBody, googleJson, googleNoContent, isRunText, listPage, pageSize, param, recordedValue, withoutQuery } from "./shared.mjs";
+import { eventFields, mintedEventId, mintedEventIdPattern } from "./state.mjs";
+import { Predicate } from "effect";
+//#region src/google/calendar.ts
+/**
+* Calendar routes of the Google emulator (internal): the time-range event listing with page
+* tokens, and the lifecycle of a run-scoped event without attendees (create, read, PATCH rename,
+* delete to `cancelled`, and the recorded 410 of a repeated delete).
+*
+* Every answer comes from the Calendar fixtures, through the seed or the request, or is minted
+* (event ids, page tokens, `created` / `updated` from the injectable clock). A deleted event stays
+* in the state as `cancelled`, as the fixtures read it back.
+*
+* @experimental
+*/
+/** Path of the events collection of `{calendarId}`. */
+const calendarEventsPath = "/calendar/v3/calendars/{calendarId}/events";
+const listCase = "google.calendar.list-range-paging";
+const lifecycleCase = "google.calendar.event-lifecycle";
+const deletedCase = "google.calendar.deleted-event-gone";
+/** A raw calendar id segment: an address-like id, its `@` percent-encoded once (`%40`). */
+const calendarIdSegment = /^[A-Za-z0-9._+-]{1,200}(?:%40[A-Za-z0-9.-]{1,200})?$/;
+const eventIdSegment = /^[A-Za-z0-9_-]{1,1024}$/;
+const calendar = (method, path, write, caseIds, withEvent) => evidence(googleEmulatorApisOrigin, method, `${calendarEventsPath}${path}`, write, caseIds, withEvent ? {
+	calendarId: calendarIdSegment,
+	eventId: eventIdSegment
+} : { calendarId: calendarIdSegment });
+const createdDescription = "Synthetic conformance event without attendees.";
+const renamedDescription = "Synthetic conformance event, renamed.";
+const eventSummaryRest = "synthetic conformance event, safe to delete";
+/** The fixed half hour every recorded event create sends. */
+const recordedStart = {
+	dateTime: "2030-01-07T09:00:00Z",
+	timeZone: "UTC"
+};
+const recordedEnd = {
+	dateTime: "2030-01-07T09:30:00Z",
+	timeZone: "UTC"
+};
+const instantPattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(?:Z|[+-](\d{2}):(\d{2}))$/;
+/**
+* True for an RFC 3339 instant with a `Z` or numeric offset whose components are in range (a real
+* calendar date, hour 0-23, minute and second 0-59, offset hour 0-23 and minute 0-59), checked
+* before `Date.parse`, which would roll an out-of-range component over instead of refusing it.
+*/
+const isInstant = (text) => {
+	const parts = instantPattern.exec(text);
+	if (parts === null) return false;
+	const [year, month, day, hour, minute, second, offsetHour, offsetMinute] = parts.slice(1).map((part) => Number(part ?? "0"));
+	if (year === void 0 || month === void 0 || day === void 0) return false;
+	const days = [
+		31,
+		year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	][month - 1] ?? 0;
+	return day >= 1 && day <= days && (hour ?? 24) <= 23 && (minute ?? 60) <= 59 && (second ?? 60) <= 59 && (offsetHour ?? 24) <= 23 && (offsetMinute ?? 60) <= 59 && Number.isFinite(Date.parse(text));
+};
+const renderEvent = (state, owner, event) => {
+	const head = {
+		kind: "calendar#event",
+		etag: event.etag,
+		id: event.id,
+		status: event.status,
+		htmlLink: event.htmlLink,
+		created: event.created,
+		updated: event.updated,
+		summary: event.summary
+	};
+	if (event.description !== void 0) head.description = event.description;
+	return {
+		...head,
+		creator: {
+			email: state.practiceAddress,
+			self: true
+		},
+		organizer: {
+			email: owner.id,
+			displayName: owner.summary,
+			self: true
+		},
+		start: { ...event.start },
+		end: { ...event.end },
+		iCalUID: event.iCalUID,
+		sequence: event.sequence,
+		reminders: { useDefault: true },
+		eventType: "default"
+	};
+};
+/** The instant a boundary starts (an all-day date at midnight UTC), in milliseconds. */
+const instant = (boundary) => "dateTime" in boundary ? Date.parse(boundary.dateTime) : Date.parse(`${boundary.date}T00:00:00Z`);
+const findCalendar = (state, id) => state.calendars.find((candidate) => candidate.id === id);
+const findEvent = (state, calendarId, eventId) => state.events.find((event) => event.calendarId === calendarId && event.id === eventId);
+const isCreatedHere = (event) => mintedEventIdPattern.test(event.id);
+const replaceEvent = (state, next) => state.events.map((event) => event.calendarId === next.calendarId && event.id === next.id ? next : event);
+/** The `{ dateTime, timeZone }` boundary a fixture records, exactly. */
+const isRecordedBoundary = (value, recorded) => {
+	const boundary = exactBodyKeys(value, "boundary", ["dateTime", "timeZone"]);
+	return !isNotEmulated(boundary) && boundary.dateTime === recorded.dateTime && boundary.timeZone === recorded.timeZone;
+};
+const listEvents = statefulRoute(calendar("GET", "", false, [listCase], false), "none", (request) => {
+	const query = exactQuery(request, [
+		"timeMin",
+		"timeMax",
+		"maxResults",
+		"singleEvents",
+		"orderBy"
+	], ["pageToken"]);
+	if (isNotEmulated(query)) return query;
+	const recorded = recordedValue(query, "singleEvents", "true") ?? recordedValue(query, "orderBy", "startTime");
+	if (recorded !== void 0) return recorded;
+	const timeMin = query["timeMin"] ?? "";
+	const timeMax = query["timeMax"] ?? "";
+	if (!isInstant(timeMin) || !isInstant(timeMax) || !(Date.parse(timeMin) < Date.parse(timeMax))) return notEmulated("timeMin and timeMax must be RFC 3339 instants, timeMin first");
+	const maxResults = pageSize(query["maxResults"], "maxResults", 1, 2500);
+	if (isNotEmulated(maxResults)) return maxResults;
+	const pageToken = query["pageToken"];
+	return pageToken === "" ? notEmulated("an empty pageToken is not emulated") : {
+		calendarId: param(request, "calendarId"),
+		timeMin,
+		timeMax,
+		maxResults,
+		pageToken
+	};
+}, (state, input, { env }) => {
+	const owner = findCalendar(state, input.calendarId);
+	if (owner === void 0) return notEmulated("a calendar the state does not hold");
+	const from = Date.parse(input.timeMin);
+	const to = Date.parse(input.timeMax);
+	const overlapping = state.events.filter((event) => event.calendarId === owner.id && instant(event.start) < to && instant(event.end) > from).sort((left, right) => instant(left.start) - instant(right.start));
+	if (overlapping.length === 0) return notEmulated("a range without events is not emulated (no fixture records one)");
+	if (overlapping.some((event) => event.status === "cancelled")) return notEmulated("a range holding a cancelled event is not emulated");
+	return listPage(env, "calendar", `calendar\u0000${owner.id}\u0000${input.timeMin}\u0000${input.timeMax}\u0000${input.maxResults}`, overlapping.map((event) => renderEvent(state, owner, event)), input.maxResults, input.pageToken, env.drills.calendarPageRepeats, (page, nextPageToken) => {
+		const body = {
+			kind: "calendar#events",
+			summary: owner.summary,
+			timeZone: owner.timeZone,
+			accessRole: owner.accessRole,
+			items: [...page]
+		};
+		if (nextPageToken !== void 0) body.nextPageToken = nextPageToken;
+		return googleJson(200, body);
+	});
+});
+const createEvent = statefulRoute(calendar("POST", "", true, [lifecycleCase, deletedCase], false), "json", (request) => {
+	const body = withoutQuery(request) ?? exactBodyKeys(request.json, "the event body", [
+		"summary",
+		"description",
+		"start",
+		"end"
+	]);
+	if (isNotEmulated(body)) return body;
+	const summary = Predicate.isString(body.summary) ? body.summary : "";
+	if (!isRunText(summary, "event", eventSummaryRest) && !isRunText(summary, "deleted event", eventSummaryRest)) return notEmulated("an event summary other than the recorded run-scoped ones");
+	if (body.description !== createdDescription) return notEmulated("an event description other than the recorded one is not emulated");
+	return isRecordedBoundary(body.start, recordedStart) && isRecordedBoundary(body.end, recordedEnd) ? {
+		calendarId: param(request, "calendarId"),
+		summary
+	} : notEmulated("event times other than the recorded half hour are not emulated");
+}, (state, input, { env }) => {
+	const owner = findCalendar(state, input.calendarId);
+	if (owner === void 0) return notEmulated("a calendar the state does not hold");
+	return () => {
+		const at = new Date(env.now()).toISOString();
+		const number = state.counters.nextEventNumber;
+		const id = mintedEventId(number);
+		const event = {
+			calendarId: owner.id,
+			id,
+			...eventFields(id),
+			status: "confirmed",
+			created: at,
+			updated: at,
+			summary: input.summary,
+			description: createdDescription,
+			start: { ...recordedStart },
+			end: { ...recordedEnd },
+			sequence: 0
+		};
+		state.counters = {
+			...state.counters,
+			nextEventNumber: number + 1
+		};
+		state.events = [...state.events, event];
+		return googleJson(200, renderEvent(state, owner, event));
+	};
+});
+const eventRef = (request) => ({
+	calendarId: param(request, "calendarId"),
+	eventId: param(request, "eventId")
+});
+/** The Calendar routes, in manifest order. */
+const calendarRoutes = [
+	listEvents,
+	createEvent,
+	statefulRoute(calendar("GET", "/{eventId}", false, [lifecycleCase, deletedCase], true), "none", (request) => withoutQuery(request) ?? eventRef(request), (state, input) => {
+		const owner = findCalendar(state, input.calendarId);
+		const event = findEvent(state, input.calendarId, input.eventId);
+		return owner === void 0 || event === void 0 ? notEmulated("an event the state does not hold is not emulated") : answer(() => googleJson(200, renderEvent(state, owner, event)));
+	}),
+	statefulRoute(calendar("PATCH", "/{eventId}", true, [lifecycleCase], true), "json", (request) => {
+		const body = withoutQuery(request) ?? exactBodyKeys(request.json, "the event patch", ["summary", "description"]);
+		if (isNotEmulated(body)) return body;
+		const summary = Predicate.isString(body.summary) ? body.summary : "";
+		return isRunText(summary, "event renamed", eventSummaryRest) && body.description === renamedDescription ? {
+			...eventRef(request),
+			summary
+		} : notEmulated("an event patch other than the recorded rename is not emulated");
+	}, (state, input, { env }) => {
+		const owner = findCalendar(state, input.calendarId);
+		const event = findEvent(state, input.calendarId, input.eventId);
+		if (owner === void 0 || event === void 0 || !isCreatedHere(event) || event.status !== "confirmed") return notEmulated("renaming anything but a live event created here is not emulated");
+		return () => {
+			const at = new Date(env.now()).toISOString();
+			const next = {
+				...event,
+				updated: at,
+				summary: env.drills.eventPatchKeepsSummary ? event.summary : input.summary,
+				description: renamedDescription
+			};
+			state.events = replaceEvent(state, next);
+			return googleJson(200, renderEvent(state, owner, next));
+		};
+	}),
+	statefulRoute(calendar("DELETE", "/{eventId}", true, [lifecycleCase, deletedCase], true), "none", (request) => withoutQuery(request) ?? eventRef(request), (state, input, { env }) => {
+		const event = findEvent(state, input.calendarId, input.eventId);
+		if (event === void 0 || !isCreatedHere(event)) return notEmulated("deleting anything but an event created here is not emulated");
+		if (event.status === "cancelled") return answer(() => googleJson(env.drills.repeatedEventDeleteConflict ? 409 : 410, googleErrorBody(410, "Resource has been deleted", "deleted", "GONE")));
+		return () => {
+			const at = new Date(env.now()).toISOString();
+			state.events = replaceEvent(state, {
+				...event,
+				status: "cancelled",
+				updated: at
+			});
+			return googleNoContent();
+		};
+	})
+];
+//#endregion
+export { calendarEventsPath, calendarRoutes };
+
+//# sourceMappingURL=calendar.mjs.map

package/dist/google/calendar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.mjs","names":[],"sources":["../../src/google/calendar.ts"],"sourcesContent":["/**\n * Calendar routes of the Google emulator (internal): the time-range event listing with page\n * tokens, and the lifecycle of a run-scoped event without attendees (create, read, PATCH rename,\n * delete to `cancelled`, and the recorded 410 of a repeated delete).\n *\n * Every answer comes from the Calendar fixtures, through the seed or the request, or is minted\n * (event ids, page tokens, `created` / `updated` from the injectable clock). A deleted event stays\n * in the state as `cancelled`, as the fixtures read it back.\n *\n * @experimental\n */\nimport { Predicate } from 'effect'\nimport type * as Schema from 'effect/Schema'\nimport {\n  exactBodyKeys,\n  exactQuery,\n  isNotEmulated,\n  notEmulated,\n  statefulRoute,\n  type EmulatedRequest,\n  type NotEmulated\n} from '../stateful-emulator.ts'\nimport {\n  answer,\n  evidence,\n  googleEmulatorApisOrigin,\n  googleErrorBody,\n  googleJson,\n  googleNoContent,\n  isRunText,\n  listPage,\n  pageSize,\n  param,\n  recordedValue,\n  withoutQuery,\n  type GoogleRoute\n} from './shared.ts'\nimport {\n  eventFields,\n  mintedEventId,\n  mintedEventIdPattern,\n  type GoogleEmulatorCalendar,\n  type GoogleEmulatorCalendarEvent,\n  type GoogleEmulatorEventBoundary,\n  type GoogleEmulatorState\n} from './state.ts'\n\n/** Path of the events collection of `{calendarId}`. */\nexport const calendarEventsPath = '/calendar/v3/calendars/{calendarId}/events'\n\nconst listCase = 'google.calendar.list-range-paging'\n\nconst lifecycleCase = 'google.calendar.event-lifecycle'\n\nconst deletedCase = 'google.calendar.deleted-event-gone'\n\n/** A raw calendar id segment: an address-like id, its `@` percent-encoded once (`%40`). */\nconst calendarIdSegment = /^[A-Za-z0-9._+-]{1,200}(?:%40[A-Za-z0-9.-]{1,200})?$/\n\nconst eventIdSegment = /^[A-Za-z0-9_-]{1,1024}$/\n\nconst calendar = (\n  method: string,\n  path: string,\n  write: boolean,\n  caseIds: ReadonlyArray<string>,\n  withEvent: boolean\n) =>\n  evidence(\n    googleEmulatorApisOrigin,\n    method,\n    `${calendarEventsPath}${path}`,\n    write,\n    caseIds,\n    withEvent\n      ? { calendarId: calendarIdSegment, eventId: eventIdSegment }\n      : { calendarId: calendarIdSegment }\n  )\n\n// Recorded values.\n\nconst createdDescription = 'Synthetic conformance event without attendees.'\n\nconst renamedDescription = 'Synthetic conformance event, renamed.'\n\nconst eventSummaryRest = 'synthetic conformance event, safe to delete'\n\n/** The fixed half hour every recorded event create sends. */\nconst recordedStart = { dateTime: '2030-01-07T09:00:00Z', timeZone: 'UTC' }\n\nconst recordedEnd = { dateTime: '2030-01-07T09:30:00Z', timeZone: 'UTC' }\n\nconst instantPattern =\n  /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:\\.\\d{1,9})?(?:Z|[+-](\\d{2}):(\\d{2}))$/\n\n/**\n * True for an RFC 3339 instant with a `Z` or numeric offset whose components are in range (a real\n * calendar date, hour 0-23, minute and second 0-59, offset hour 0-23 and minute 0-59), checked\n * before `Date.parse`, which would roll an out-of-range component over instead of refusing it.\n */\nconst isInstant = (text: string): boolean => {\n  const parts = instantPattern.exec(text)\n\n  if (parts === null) return false\n\n  const [year, month, day, hour, minute, second, offsetHour, offsetMinute] = parts\n    .slice(1)\n    .map(part => Number(part ?? '0'))\n\n  if (year === undefined || month === undefined || day === undefined) return false\n\n  const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0\n  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] ?? 0\n\n  return (\n    day >= 1 &&\n    day <= days &&\n    (hour ?? 24) <= 23 &&\n    (minute ?? 60) <= 59 &&\n    (second ?? 60) <= 59 &&\n    (offsetHour ?? 24) <= 23 &&\n    (offsetMinute ?? 60) <= 59 &&\n    Number.isFinite(Date.parse(text))\n  )\n}\n\n// Rendering, in the fixture key order.\n\ntype EventHead = {\n  readonly kind: string\n  readonly etag: string\n  readonly id: string\n  readonly status: string\n  readonly htmlLink: string\n  readonly created: string\n  readonly updated: string\n  readonly summary: string\n  description?: string\n}\n\ntype EventsPage = {\n  readonly kind: string\n  readonly summary: string\n  readonly timeZone: string\n  readonly accessRole: string\n  readonly items: ReadonlyArray<Schema.Json>\n  nextPageToken?: string\n}\n\nconst renderEvent = (\n  state: GoogleEmulatorState,\n  owner: GoogleEmulatorCalendar,\n  event: GoogleEmulatorCalendarEvent\n): Schema.JsonObject => {\n  const head: EventHead = {\n    kind: 'calendar#event',\n    etag: event.etag,\n    id: event.id,\n    status: event.status,\n    htmlLink: event.htmlLink,\n    created: event.created,\n    updated: event.updated,\n    summary: event.summary\n  }\n\n  // The fixtures show `description` only on events that have one.\n  if (event.description !== undefined) head.description = event.description\n\n  return {\n    ...head,\n    creator: { email: state.practiceAddress, self: true },\n    organizer: { email: owner.id, displayName: owner.summary, self: true },\n    start: { ...event.start },\n    end: { ...event.end },\n    iCalUID: event.iCalUID,\n    sequence: event.sequence,\n    reminders: { useDefault: true },\n    eventType: 'default'\n  }\n}\n\n/** The instant a boundary starts (an all-day date at midnight UTC), in milliseconds. */\nconst instant = (boundary: GoogleEmulatorEventBoundary): number =>\n  'dateTime' in boundary ? Date.parse(boundary.dateTime) : Date.parse(`${boundary.date}T00:00:00Z`)\n\nconst findCalendar = (state: GoogleEmulatorState, id: string) =>\n  state.calendars.find(candidate => candidate.id === id)\n\nconst findEvent = (state: GoogleEmulatorState, calendarId: string, eventId: string) =>\n  state.events.find(event => event.calendarId === calendarId && event.id === eventId)\n\nconst isCreatedHere = (event: GoogleEmulatorCalendarEvent): boolean =>\n  mintedEventIdPattern.test(event.id)\n\nconst replaceEvent = (state: GoogleEmulatorState, next: GoogleEmulatorCalendarEvent) =>\n  state.events.map(event =>\n    event.calendarId === next.calendarId && event.id === next.id ? next : event\n  )\n\n/** The `{ dateTime, timeZone }` boundary a fixture records, exactly. */\nconst isRecordedBoundary = (\n  value: Schema.Json | undefined,\n  recorded: { readonly dateTime: string; readonly timeZone: string }\n): boolean => {\n  const boundary = exactBodyKeys(value, 'boundary', ['dateTime', 'timeZone'])\n\n  return (\n    !isNotEmulated(boundary) &&\n    boundary.dateTime === recorded.dateTime &&\n    boundary.timeZone === recorded.timeZone\n  )\n}\n\n// Listing.\n\ntype ListInput = {\n  readonly calendarId: string\n  readonly timeMin: string\n  readonly timeMax: string\n  readonly maxResults: number\n  readonly pageToken: string | undefined\n}\n\nconst listEvents: GoogleRoute = statefulRoute(\n  calendar('GET', '', false, [listCase], false),\n  'none',\n  (request): ListInput | NotEmulated => {\n    const query = exactQuery(\n      request,\n      ['timeMin', 'timeMax', 'maxResults', 'singleEvents', 'orderBy'],\n      ['pageToken']\n    )\n\n    if (isNotEmulated(query)) return query\n\n    const recorded =\n      recordedValue(query, 'singleEvents', 'true') ?? recordedValue(query, 'orderBy', 'startTime')\n\n    if (recorded !== undefined) return recorded\n\n    const timeMin = query['timeMin'] ?? ''\n    const timeMax = query['timeMax'] ?? ''\n\n    if (\n      !isInstant(timeMin) ||\n      !isInstant(timeMax) ||\n      !(Date.parse(timeMin) < Date.parse(timeMax))\n    ) {\n      return notEmulated('timeMin and timeMax must be RFC 3339 instants, timeMin first')\n    }\n\n    const maxResults = pageSize(query['maxResults'], 'maxResults', 1, 2500)\n\n    if (isNotEmulated(maxResults)) return maxResults\n\n    const pageToken = query['pageToken']\n\n    return pageToken === ''\n      ? notEmulated('an empty pageToken is not emulated')\n      : { calendarId: param(request, 'calendarId'), timeMin, timeMax, maxResults, pageToken }\n  },\n  (state, input, { env }) => {\n    const owner = findCalendar(state, input.calendarId)\n\n    if (owner === undefined) return notEmulated('a calendar the state does not hold')\n\n    const from = Date.parse(input.timeMin)\n    const to = Date.parse(input.timeMax)\n\n    // By start time (`orderBy=startTime`); `sort` is stable, so equal starts keep the state order.\n    const overlapping = state.events\n      .filter(\n        event =>\n          event.calendarId === owner.id && instant(event.start) < to && instant(event.end) > from\n      )\n      .sort((left, right) => instant(left.start) - instant(right.start))\n\n    // Every recorded listing has events, and none of them is cancelled.\n    if (overlapping.length === 0) {\n      return notEmulated('a range without events is not emulated (no fixture records one)')\n    }\n\n    if (overlapping.some(event => event.status === 'cancelled')) {\n      return notEmulated('a range holding a cancelled event is not emulated')\n    }\n\n    return listPage(\n      env,\n      'calendar',\n      `calendar\\u0000${owner.id}\\u0000${input.timeMin}\\u0000${input.timeMax}\\u0000${input.maxResults}`,\n      overlapping.map(event => renderEvent(state, owner, event)),\n      input.maxResults,\n      input.pageToken,\n      env.drills.calendarPageRepeats,\n      (page, nextPageToken) => {\n        const body: EventsPage = {\n          kind: 'calendar#events',\n          summary: owner.summary,\n          timeZone: owner.timeZone,\n          accessRole: owner.accessRole,\n          items: [...page]\n        }\n\n        // The last page carries no `nextPageToken`.\n        if (nextPageToken !== undefined) body.nextPageToken = nextPageToken\n\n        return googleJson(200, body)\n      }\n    )\n  }\n)\n\n// The event lifecycle.\n\ntype CreateInput = { readonly calendarId: string; readonly summary: string }\n\nconst createEvent: GoogleRoute = statefulRoute(\n  calendar('POST', '', true, [lifecycleCase, deletedCase], false),\n  'json',\n  (request): CreateInput | NotEmulated => {\n    const body =\n      withoutQuery(request) ??\n      exactBodyKeys(request.json, 'the event body', ['summary', 'description', 'start', 'end'])\n\n    if (isNotEmulated(body)) return body\n\n    const summary = Predicate.isString(body.summary) ? body.summary : ''\n\n    if (\n      !isRunText(summary, 'event', eventSummaryRest) &&\n      !isRunText(summary, 'deleted event', eventSummaryRest)\n    ) {\n      return notEmulated('an event summary other than the recorded run-scoped ones')\n    }\n\n    if (body.description !== createdDescription) {\n      return notEmulated('an event description other than the recorded one is not emulated')\n    }\n\n    return isRecordedBoundary(body.start, recordedStart) &&\n      isRecordedBoundary(body.end, recordedEnd)\n      ? { calendarId: param(request, 'calendarId'), summary }\n      : notEmulated('event times other than the recorded half hour are not emulated')\n  },\n  (state, input, { env }) => {\n    const owner = findCalendar(state, input.calendarId)\n\n    if (owner === undefined) return notEmulated('a calendar the state does not hold')\n\n    return () => {\n      // Read the clock before any write: a failing clock writes nothing.\n      const at = new Date(env.now()).toISOString()\n      const number = state.counters.nextEventNumber\n      const id = mintedEventId(number)\n\n      const event: GoogleEmulatorCalendarEvent = {\n        calendarId: owner.id,\n        id,\n        ...eventFields(id),\n        status: 'confirmed',\n        created: at,\n        updated: at,\n        summary: input.summary,\n        description: createdDescription,\n        start: { ...recordedStart },\n        end: { ...recordedEnd },\n        sequence: 0\n      }\n\n      state.counters = { ...state.counters, nextEventNumber: number + 1 }\n      state.events = [...state.events, event]\n\n      return googleJson(200, renderEvent(state, owner, event))\n    }\n  }\n)\n\ntype EventRef = { readonly calendarId: string; readonly eventId: string }\n\nconst eventRef = (request: EmulatedRequest): EventRef => ({\n  calendarId: param(request, 'calendarId'),\n  eventId: param(request, 'eventId')\n})\n\nconst getEvent: GoogleRoute = statefulRoute(\n  calendar('GET', '/{eventId}', false, [lifecycleCase, deletedCase], true),\n  'none',\n  request => withoutQuery(request) ?? eventRef(request),\n  (state, input) => {\n    const owner = findCalendar(state, input.calendarId)\n    const event = findEvent(state, input.calendarId, input.eventId)\n\n    return owner === undefined || event === undefined\n      ? notEmulated('an event the state does not hold is not emulated')\n      : answer(() => googleJson(200, renderEvent(state, owner, event)))\n  }\n)\n\ntype PatchInput = EventRef & { readonly summary: string }\n\nconst patchEvent: GoogleRoute = statefulRoute(\n  calendar('PATCH', '/{eventId}', true, [lifecycleCase], true),\n  'json',\n  (request): PatchInput | NotEmulated => {\n    const body =\n      withoutQuery(request) ??\n      exactBodyKeys(request.json, 'the event patch', ['summary', 'description'])\n\n    if (isNotEmulated(body)) return body\n\n    const summary = Predicate.isString(body.summary) ? body.summary : ''\n\n    return isRunText(summary, 'event renamed', eventSummaryRest) &&\n      body.description === renamedDescription\n      ? { ...eventRef(request), summary }\n      : notEmulated('an event patch other than the recorded rename is not emulated')\n  },\n  (state, input, { env }) => {\n    const owner = findCalendar(state, input.calendarId)\n    const event = findEvent(state, input.calendarId, input.eventId)\n\n    if (\n      owner === undefined ||\n      event === undefined ||\n      !isCreatedHere(event) ||\n      event.status !== 'confirmed'\n    ) {\n      return notEmulated('renaming anything but a live event created here is not emulated')\n    }\n\n    return () => {\n      const at = new Date(env.now()).toISOString()\n\n      const next: GoogleEmulatorCalendarEvent = {\n        ...event,\n        updated: at,\n        summary: env.drills.eventPatchKeepsSummary ? event.summary : input.summary,\n        description: renamedDescription\n      }\n\n      state.events = replaceEvent(state, next)\n\n      return googleJson(200, renderEvent(state, owner, next))\n    }\n  }\n)\n\nconst deleteEvent: GoogleRoute = statefulRoute(\n  calendar('DELETE', '/{eventId}', true, [lifecycleCase, deletedCase], true),\n  'none',\n  request => withoutQuery(request) ?? eventRef(request),\n  (state, input, { env }) => {\n    const event = findEvent(state, input.calendarId, input.eventId)\n\n    if (event === undefined || !isCreatedHere(event)) {\n      return notEmulated('deleting anything but an event created here is not emulated')\n    }\n\n    // The recorded repeated delete: 410 Gone (the drill answers it as 409).\n    if (event.status === 'cancelled') {\n      return answer(() =>\n        googleJson(\n          env.drills.repeatedEventDeleteConflict ? 409 : 410,\n          googleErrorBody(410, 'Resource has been deleted', 'deleted', 'GONE')\n        )\n      )\n    }\n\n    return () => {\n      const at = new Date(env.now()).toISOString()\n\n      state.events = replaceEvent(state, { ...event, status: 'cancelled', updated: at })\n\n      return googleNoContent()\n    }\n  }\n)\n\n/** The Calendar routes, in manifest order. */\nexport const calendarRoutes: ReadonlyArray<GoogleRoute> = [\n  listEvents,\n  createEvent,\n  getEvent,\n  patchEvent,\n  deleteEvent\n]\n"],"mappings":"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"}

package/dist/google/drive.d.mts

@@ -0,0 +1,8 @@
+import { GoogleRoute } from "./shared.mjs";
+
+//#region src/google/drive.d.ts
+/** The Drive routes, in manifest order. */
+declare const driveRoutes: ReadonlyArray<GoogleRoute>;
+//#endregion
+export { driveRoutes };
+//# sourceMappingURL=drive.d.mts.map

package/dist/google/drive.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.mts","names":[],"sources":["../../src/google/drive.ts"],"mappings":";;;;cAgda,WAAA,EAAa,aAAa,CAAC,WAAA"}