@yolk-sdk/emulators 0.1.0-canary.96

package/dist/telegram.d.mts

@@ -0,0 +1,62 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulCoverage, StatefulFault, StatefulFaultMatch, StatefulFaultState, StatefulHeaderlessLedgerEntry } from "./stateful-emulator.mjs";
+import { TelegramEmulatorBot, TelegramEmulatorChat, TelegramEmulatorFile, TelegramEmulatorProfile, TelegramEmulatorSeed, TelegramEmulatorSentMessage, TelegramEmulatorState, TelegramEmulatorStateSchema } from "./telegram/state.mjs";
+import { TelegramEmulatorDrills } from "./telegram/api.mjs";
+
+//#region src/telegram.d.ts
+/** Origin the connector calls (Bot API methods and hosted file downloads). */
+declare const telegramEmulatorDefaultOrigin = "https://api.telegram.org";
+/**
+ * Route evidence manifest: every emulated route, whether it writes, and the conformance cases
+ * whose (currently synthetic, unverified) wire claims it follows. `{token}` stands for the bot
+ * token path segment, which is never recorded.
+ */
+declare const telegramEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+type TelegramFaultState = StatefulFaultState;
+type TelegramLedgerEntry = StatefulHeaderlessLedgerEntry;
+type TelegramCoverage = StatefulCoverage;
+declare const TelegramEmulatorInputInvalid_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: "TelegramEmulatorInputInvalid";
+} & Readonly<A>;
+/** Invalid emulator input from the JS API: a seed or a fault. A programmer error. */
+declare class TelegramEmulatorInputInvalid extends TelegramEmulatorInputInvalid_base<{
+  readonly input: 'seed' | 'fault';
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type TelegramEmulatorOptions = {
+  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */readonly seed?: TelegramEmulatorSeed; /** Clock in epoch milliseconds (`date` of sent messages). Defaults to `Date.now`. */
+  readonly now?: () => number; /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */
+  readonly drills?: TelegramEmulatorDrills;
+};
+type TelegramEmulator = {
+  /** The fetch handler (Bot API routes, file downloads, and `/_emulate/*`). Never rejects. */readonly fetch: (request: Request) => Promise<Response>;
+  readonly ledger: {
+    readonly entries: () => ReadonlyArray<TelegramLedgerEntry>;
+    readonly clear: () => void;
+  };
+  readonly faults: {
+    /** Add a fault; throws `TelegramEmulatorInputInvalid` for an invalid fault. */readonly add: (fault: StatefulFault) => TelegramFaultState;
+    readonly list: () => ReadonlyArray<TelegramFaultState>;
+    readonly clear: () => void;
+  }; /** Restore the current seed (dropping sent messages) and clear the ledger and faults. */
+  readonly reset: () => Promise<void>;
+  /**
+   * Replace the state with a new seed, which becomes what `reset` restores. Rejects with
+   * `TelegramEmulatorInputInvalid` for an invalid seed.
+   */
+  readonly seed: (seed: TelegramEmulatorSeed) => Promise<void>; /** A deep copy of the current state (entities, sent messages, and the message counter). */
+  readonly snapshot: () => TelegramEmulatorState;
+  readonly coverage: () => TelegramCoverage; /** Close the core runtime. Later requests answer 503. Idempotent. */
+  readonly close: () => Promise<void>;
+};
+/**
+ * Create a stateful Telegram Bot API emulator on the `@emulators/core` custom runtime. Each call
+ * has its own state, ledger, and faults. Rejects with `TelegramEmulatorInputInvalid` for an
+ * invalid seed. See `README.md` (Telegram emulator) for the wire claims.
+ */
+declare const makeTelegramEmulator: (options?: TelegramEmulatorOptions) => Promise<TelegramEmulator>;
+//#endregion
+export { type EmulatorEvidence, type EmulatorRouteEvidence, TelegramCoverage, TelegramEmulator, TelegramEmulatorBot, TelegramEmulatorChat, type TelegramEmulatorDrills, TelegramEmulatorFile, TelegramEmulatorInputInvalid, TelegramEmulatorOptions, TelegramEmulatorProfile, TelegramEmulatorSeed, TelegramEmulatorSentMessage, type TelegramEmulatorState, TelegramEmulatorStateSchema, StatefulFault as TelegramFault, StatefulFaultMatch as TelegramFaultMatch, TelegramFaultState, TelegramLedgerEntry, emulatorEvidenceHeader, makeTelegramEmulator, telegramEmulatorDefaultOrigin, telegramEmulatorRoutes };
+//# sourceMappingURL=telegram.d.mts.map

package/dist/telegram.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.d.mts","names":[],"sources":["../src/telegram.ts"],"mappings":";;;;;;;cAwFa,6BAAA;AAOb;;;;AAAwE;AAAxE,cAAa,sBAAA,EAAwB,aAAa,CAAC,qBAAA;AAAA,KAIvC,kBAAA,GAAqB,kBAAkB;AAAA,KAEvC,mBAAA,GAAsB,6BAA6B;AAAA,KAEnD,gBAAA,GAAmB,gBAAgB;AAAA,cAAA,iCAAA;;;;cAGlC,4BAAA,SAAqC,iCAAA;EAAA,SACvC,KAAA;EAAA,SACA,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,uBAAA;EAZmC,oFAcpC,IAAA,GAAO,oBAAA;WAEP,GAAA;WAEA,MAAA,GAAS,sBAAsB;AAAA;AAAA,KAG9B,gBAAA;uGAED,KAAA,GAAQ,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;EAAA,SACrC,MAAA;IAAA,SACE,OAAA,QAAe,aAAA,CAAc,mBAAA;IAAA,SAC7B,KAAA;EAAA;EAAA,SAEF,MAAA;4FAEE,GAAA,GAAM,KAAA,EAAO,aAAA,KAAkB,kBAAA;IAAA,SAC/B,IAAA,QAAY,aAAA,CAAc,kBAAA;IAAA,SAC1B,KAAA;EAAA;WAGF,KAAA,QAAa,OAAA;;;;;WAKb,IAAA,GAAO,IAAA,EAAM,oBAAA,KAAyB,OAAA;WAEtC,QAAA,QAAgB,qBAAA;EAAA,SAChB,QAAA,QAAgB,gBAAA,EAxCe;EAAA,SA0C/B,KAAA,QAAa,OAAA;AAAA;;;;;;cAmBX,oBAAA,GACX,OAAA,GAAS,uBAAA,KACR,OAAA,CAAQ,gBAAA"}

package/dist/telegram.mjs

@@ -0,0 +1,127 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, makeHeaderlessStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { resolveTelegramRequest, telegramApiRoutes } from "./telegram/api.mjs";
+import { TelegramEmulatorBot, TelegramEmulatorChat, TelegramEmulatorFile, TelegramEmulatorProfile, TelegramEmulatorSeed, TelegramEmulatorSentMessage, TelegramEmulatorStateSchema, buildTelegramSeedState, decodeTelegramState } from "./telegram/state.mjs";
+import { Data, Predicate } from "effect";
+//#region src/telegram.ts
+/**
+* Stateful Telegram Bot API emulator (`https://api.telegram.org`), built on the upstream
+* `@emulators/core` custom runtime, with a request ledger, status faults, and an `/_emulate/*`
+* control plane.
+*
+* Fixture-only: it never imports SDK code; its wire shapes and default seed are copied as data
+* from the synthetic Telegram conformance fixtures, and every route names the conformance cases it
+* follows in `telegramEmulatorRoutes`. Only the routes the four Telegram cases need are emulated
+* (`getChat`, `getFile`, the hosted file download, `sendMessage`); anything the fixtures do not
+* record answers one ledgered 400 `{ error: { type: 'not_emulated', message } }`.
+*
+* The bot token travels in the URL path (`/bot<token>/<method>`). It is required but never checked
+* against a value, stored, forwarded to the core, ledgered, or echoed. Resolution fails closed: a
+* request is recognised only when its raw path is exactly an emulated route shape
+* (`/bot<token>/<method>` or `/file/bot<token>/<file_path>`, the strict token on the raw segment,
+* an emulated method, no other path text); the token is taken from that exact segment. Every other
+* request is ledgered and answered with constant text only (`/<unrecognised>`, a standard method or
+* `<other>`, no query or body, a constant reason). For a recognised request, the ledgered method,
+* path (`/bot<redacted>/...`), query keys and values, and every not-emulated message are scrubbed
+* of the token and its secret part, and a query, remaining path, or body that repeats either (raw,
+* percent-decoded, or in any parsed JSON key, string value, or number) is refused with constant
+* text. A token whose bot id is `0` names no bot: `getChat` answers the recorded 401.
+*
+* `sendMessage` is irreversible on the real service; the emulator records each sent message in its
+* state (`sentMessages`) and never delivers anything.
+*
+* Request-shape latitude (the only accepted deviations from the fixture requests): any credential
+* value of at least 8 characters that occurs nowhere else in the request (its path, query, or body;
+* never checked against anything, stored, or ledgered); extra request headers; `content-type`
+* parameters; a well-formed `<digits>:<secret>` bot token with a secret of at least 8 characters
+* (the bot id `0` names no bot); any well-formed `chat_id` string (an integer or a public
+* `@username`; one the bot is not in answers the recorded 400 on `getChat`); any non-empty message
+* `text`.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeTelegramEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+/** Origin the connector calls (Bot API methods and hosted file downloads). */
+const telegramEmulatorDefaultOrigin = "https://api.telegram.org";
+/**
+* Route evidence manifest: every emulated route, whether it writes, and the conformance cases
+* whose (currently synthetic, unverified) wire claims it follows. `{token}` stands for the bot
+* token path segment, which is never recorded.
+*/
+const telegramEmulatorRoutes = telegramApiRoutes.map(({ route }) => routeEvidence(route));
+/** Invalid emulator input from the JS API: a seed or a fault. A programmer error. */
+var TelegramEmulatorInputInvalid = class extends Data.TaggedError("TelegramEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Telegram emulator ${this.input}: ${this.reason}`;
+	}
+};
+/** The texts of Telegram's recovery answers (500 failed, 503 closed, 500 unhandled). */
+const errorTexts = {
+	failed: "Synthetic: the emulator could not build the response.",
+	closed: "Synthetic: the emulator is closed.",
+	unhandled: "emulator failed to handle the request"
+};
+/** The wrapper reports invalid seeds and faults only (Telegram takes no other option input). */
+const inputInvalid = (input, reason) => new TelegramEmulatorInputInvalid({
+	input: input === "seed" ? "seed" : "fault",
+	reason
+});
+/**
+* Create a stateful Telegram Bot API emulator on the `@emulators/core` custom runtime. Each call
+* has its own state, ledger, and faults. Rejects with `TelegramEmulatorInputInvalid` for an
+* invalid seed. See `README.md` (Telegram emulator) for the wire claims.
+*/
+const makeTelegramEmulator = async (options = {}) => {
+	const initial = buildTelegramSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw new TelegramEmulatorInputInvalid({
+		input: "seed",
+		reason: initial
+	});
+	const drills = options.drills ?? {};
+	const env = {
+		now: options.now ?? (() => Date.now()),
+		drills: {
+			getChatOkFalse: drills.getChatOkFalse ?? false,
+			errorsAs200: drills.errorsAs200 ?? false,
+			fileSizeOffByOne: drills.fileSizeOffByOne ?? false,
+			sendOkFalse: drills.sendOkFalse ?? false
+		}
+	};
+	const emulator = await makeHeaderlessStatefulEmulator({
+		routes: telegramApiRoutes.map(({ route }) => route),
+		env,
+		initial,
+		buildSeed: buildTelegramSeedState,
+		resolveRequest: resolveTelegramRequest,
+		errorTexts,
+		clearRuntime: () => void 0,
+		runtimeState: () => ({ runtime: {} }),
+		seedSummary: (state) => ({
+			chats: state.chats.length,
+			files: state.files.length
+		}),
+		inputInvalid
+	}, statefulCoreRuntime({
+		name: "telegram",
+		initial,
+		decodeState: decodeTelegramState,
+		inputInvalid
+	}));
+	return {
+		fetch: emulator.fetch,
+		ledger: emulator.ledger,
+		faults: emulator.faults,
+		reset: emulator.reset,
+		seed: emulator.seed,
+		snapshot: emulator.snapshot,
+		coverage: emulator.coverage,
+		close: emulator.close
+	};
+};
+//#endregion
+export { TelegramEmulatorBot, TelegramEmulatorChat, TelegramEmulatorFile, TelegramEmulatorInputInvalid, TelegramEmulatorProfile, TelegramEmulatorSeed, TelegramEmulatorSentMessage, TelegramEmulatorStateSchema, StatefulFault as TelegramFault, StatefulFaultMatch as TelegramFaultMatch, emulatorEvidenceHeader, makeTelegramEmulator, telegramEmulatorDefaultOrigin, telegramEmulatorRoutes };
+
+//# sourceMappingURL=telegram.mjs.map

package/dist/telegram.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.mjs","names":[],"sources":["../src/telegram.ts"],"sourcesContent":["/**\n * Stateful Telegram Bot API emulator (`https://api.telegram.org`), built on the upstream\n * `@emulators/core` custom runtime, with a request ledger, status faults, and an `/_emulate/*`\n * control plane.\n *\n * Fixture-only: it never imports SDK code; its wire shapes and default seed are copied as data\n * from the synthetic Telegram conformance fixtures, and every route names the conformance cases it\n * follows in `telegramEmulatorRoutes`. Only the routes the four Telegram cases need are emulated\n * (`getChat`, `getFile`, the hosted file download, `sendMessage`); anything the fixtures do not\n * record answers one ledgered 400 `{ error: { type: 'not_emulated', message } }`.\n *\n * The bot token travels in the URL path (`/bot<token>/<method>`). It is required but never checked\n * against a value, stored, forwarded to the core, ledgered, or echoed. Resolution fails closed: a\n * request is recognised only when its raw path is exactly an emulated route shape\n * (`/bot<token>/<method>` or `/file/bot<token>/<file_path>`, the strict token on the raw segment,\n * an emulated method, no other path text); the token is taken from that exact segment. Every other\n * request is ledgered and answered with constant text only (`/<unrecognised>`, a standard method or\n * `<other>`, no query or body, a constant reason). For a recognised request, the ledgered method,\n * path (`/bot<redacted>/...`), query keys and values, and every not-emulated message are scrubbed\n * of the token and its secret part, and a query, remaining path, or body that repeats either (raw,\n * percent-decoded, or in any parsed JSON key, string value, or number) is refused with constant\n * text. A token whose bot id is `0` names no bot: `getChat` answers the recorded 401.\n *\n * `sendMessage` is irreversible on the real service; the emulator records each sent message in its\n * state (`sentMessages`) and never delivers anything.\n *\n * Request-shape latitude (the only accepted deviations from the fixture requests): any credential\n * value of at least 8 characters that occurs nowhere else in the request (its path, query, or body;\n * never checked against anything, stored, or ledgered); extra request headers; `content-type`\n * parameters; a well-formed `<digits>:<secret>` bot token with a secret of at least 8 characters\n * (the bot id `0` names no bot); any well-formed `chat_id` string (an integer or a public\n * `@username`; one the bot is not in answers the recorded 400 on `getChat`); any non-empty message\n * `text`.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeTelegramEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport { statefulCoreRuntime } from './stateful-core.ts'\nimport {\n  makeHeaderlessStatefulEmulator,\n  routeEvidence,\n  type StatefulCoverage,\n  type StatefulErrorTexts,\n  type StatefulFault,\n  type StatefulFaultState,\n  type StatefulHeaderlessLedgerEntry,\n  type StatefulInputKind\n} from './stateful-emulator.ts'\nimport {\n  resolveTelegramRequest,\n  telegramApiRoutes,\n  type TelegramApiEnv,\n  type TelegramEmulatorDrills\n} from './telegram/api.ts'\nimport {\n  buildTelegramSeedState,\n  decodeTelegramState,\n  type TelegramEmulatorSeed,\n  type TelegramEmulatorState\n} from './telegram/state.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport {\n  StatefulFault as TelegramFault,\n  StatefulFaultMatch as TelegramFaultMatch\n} from './stateful-emulator.ts'\n\nexport type { TelegramEmulatorDrills } from './telegram/api.ts'\n\nexport {\n  TelegramEmulatorBot,\n  TelegramEmulatorChat,\n  TelegramEmulatorFile,\n  TelegramEmulatorProfile,\n  TelegramEmulatorSeed,\n  TelegramEmulatorSentMessage,\n  TelegramEmulatorStateSchema,\n  type TelegramEmulatorState\n} from './telegram/state.ts'\n\n/** Origin the connector calls (Bot API methods and hosted file downloads). */\nexport const telegramEmulatorDefaultOrigin = 'https://api.telegram.org'\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. `{token}` stands for the bot\n * token path segment, which is never recorded.\n */\nexport const telegramEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = telegramApiRoutes.map(\n  ({ route }) => routeEvidence(route)\n)\n\nexport type TelegramFaultState = StatefulFaultState\n\nexport type TelegramLedgerEntry = StatefulHeaderlessLedgerEntry\n\nexport type TelegramCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed or a fault. A programmer error. */\nexport class TelegramEmulatorInputInvalid extends Data.TaggedError('TelegramEmulatorInputInvalid')<{\n  readonly input: 'seed' | 'fault'\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Telegram emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type TelegramEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */\n  readonly seed?: TelegramEmulatorSeed\n  /** Clock in epoch milliseconds (`date` of sent messages). Defaults to `Date.now`. */\n  readonly now?: () => number\n  /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */\n  readonly drills?: TelegramEmulatorDrills\n}\n\nexport type TelegramEmulator = {\n  /** The fetch handler (Bot API routes, file downloads, and `/_emulate/*`). Never rejects. */\n  readonly fetch: (request: Request) => Promise<Response>\n  readonly ledger: {\n    readonly entries: () => ReadonlyArray<TelegramLedgerEntry>\n    readonly clear: () => void\n  }\n  readonly faults: {\n    /** Add a fault; throws `TelegramEmulatorInputInvalid` for an invalid fault. */\n    readonly add: (fault: StatefulFault) => TelegramFaultState\n    readonly list: () => ReadonlyArray<TelegramFaultState>\n    readonly clear: () => void\n  }\n  /** Restore the current seed (dropping sent messages) and clear the ledger and faults. */\n  readonly reset: () => Promise<void>\n  /**\n   * Replace the state with a new seed, which becomes what `reset` restores. Rejects with\n   * `TelegramEmulatorInputInvalid` for an invalid seed.\n   */\n  readonly seed: (seed: TelegramEmulatorSeed) => Promise<void>\n  /** A deep copy of the current state (entities, sent messages, and the message counter). */\n  readonly snapshot: () => TelegramEmulatorState\n  readonly coverage: () => TelegramCoverage\n  /** Close the core runtime. Later requests answer 503. Idempotent. */\n  readonly close: () => Promise<void>\n}\n\n/** The texts of Telegram's recovery answers (500 failed, 503 closed, 500 unhandled). */\nconst errorTexts: StatefulErrorTexts = {\n  failed: 'Synthetic: the emulator could not build the response.',\n  closed: 'Synthetic: the emulator is closed.',\n  unhandled: 'emulator failed to handle the request'\n}\n\n/** The wrapper reports invalid seeds and faults only (Telegram takes no other option input). */\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new TelegramEmulatorInputInvalid({ input: input === 'seed' ? 'seed' : 'fault', reason })\n\n/**\n * Create a stateful Telegram Bot API emulator on the `@emulators/core` custom runtime. Each call\n * has its own state, ledger, and faults. Rejects with `TelegramEmulatorInputInvalid` for an\n * invalid seed. See `README.md` (Telegram emulator) for the wire claims.\n */\nexport const makeTelegramEmulator = async (\n  options: TelegramEmulatorOptions = {}\n): Promise<TelegramEmulator> => {\n  const initial = buildTelegramSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw new TelegramEmulatorInputInvalid({ input: 'seed', reason: initial })\n  }\n\n  const drills = options.drills ?? {}\n\n  const env: TelegramApiEnv = {\n    now: options.now ?? (() => Date.now()),\n    drills: {\n      getChatOkFalse: drills.getChatOkFalse ?? false,\n      errorsAs200: drills.errorsAs200 ?? false,\n      fileSizeOffByOne: drills.fileSizeOffByOne ?? false,\n      sendOkFalse: drills.sendOkFalse ?? false\n    }\n  }\n\n  const emulator = await makeHeaderlessStatefulEmulator<\n    TelegramEmulatorState,\n    TelegramApiEnv,\n    TelegramEmulatorSeed\n  >(\n    {\n      routes: telegramApiRoutes.map(({ route }) => route),\n      env,\n      initial,\n      buildSeed: buildTelegramSeedState,\n      resolveRequest: resolveTelegramRequest,\n      errorTexts,\n      clearRuntime: () => undefined,\n      runtimeState: () => ({ runtime: {} }),\n      seedSummary: state => ({\n        chats: state.chats.length,\n        files: state.files.length\n      }),\n      inputInvalid\n    },\n    statefulCoreRuntime({\n      name: 'telegram',\n      initial,\n      decodeState: decodeTelegramState,\n      inputInvalid\n    })\n  )\n\n  return {\n    fetch: emulator.fetch,\n    ledger: emulator.ledger,\n    faults: emulator.faults,\n    reset: emulator.reset,\n    seed: emulator.seed,\n    snapshot: emulator.snapshot,\n    coverage: emulator.coverage,\n    close: emulator.close\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwFA,MAAa,gCAAgC;;;;;;AAO7C,MAAa,yBAA+D,kBAAkB,KAC3F,EAAE,YAAY,cAAc,KAAK,CACpC;;AASA,IAAa,+BAAb,cAAkD,KAAK,YAAY,8BAA8B,EAG9F;CACD,IAAa,UAAkB;EAC7B,OAAO,6BAA6B,KAAK,MAAM,IAAI,KAAK;CAC1D;AACF;;AAuCA,MAAM,aAAiC;CACrC,QAAQ;CACR,QAAQ;CACR,WAAW;AACb;;AAGA,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,6BAA6B;CAAE,OAAO,UAAU,SAAS,SAAS;CAAS;AAAO,CAAC;;;;;;AAOzF,MAAa,uBAAuB,OAClC,UAAmC,CAAC,MACN;CAC9B,MAAM,UAAU,uBAAuB,QAAQ,QAAQ,CAAC,CAAC;CAEzD,IAAI,UAAU,SAAS,OAAO,GAC5B,MAAM,IAAI,6BAA6B;EAAE,OAAO;EAAQ,QAAQ;CAAQ,CAAC;CAG3E,MAAM,SAAS,QAAQ,UAAU,CAAC;CAElC,MAAM,MAAsB;EAC1B,KAAK,QAAQ,cAAc,KAAK,IAAI;EACpC,QAAQ;GACN,gBAAgB,OAAO,kBAAkB;GACzC,aAAa,OAAO,eAAe;GACnC,kBAAkB,OAAO,oBAAoB;GAC7C,aAAa,OAAO,eAAe;EACrC;CACF;CAEA,MAAM,WAAW,MAAM,+BAKrB;EACE,QAAQ,kBAAkB,KAAK,EAAE,YAAY,KAAK;EAClD;EACA;EACA,WAAW;EACX,gBAAgB;EAChB;EACA,oBAAoB,KAAA;EACpB,qBAAqB,EAAE,SAAS,CAAC,EAAE;EACnC,cAAa,WAAU;GACrB,OAAO,MAAM,MAAM;GACnB,OAAO,MAAM,MAAM;EACrB;EACA;CACF,GACA,oBAAoB;EAClB,MAAM;EACN;EACA,aAAa;EACb;CACF,CAAC,CACH;CAEA,OAAO;EACL,OAAO,SAAS;EAChB,QAAQ,SAAS;EACjB,QAAQ,SAAS;EACjB,OAAO,SAAS;EAChB,MAAM,SAAS;EACf,UAAU,SAAS;EACnB,UAAU,SAAS;EACnB,OAAO,SAAS;CAClB;AACF"}

package/dist/todoist/api.d.mts

@@ -0,0 +1,55 @@
+import { StatefulRoute } from "../stateful-emulator.mjs";
+import { TodoistEmulatorState } from "./state.mjs";
+
+//#region src/todoist/api.d.ts
+/** API v1 prefix of every Todoist route. */
+declare const todoistEmulatorBasePath = "/api/v1";
+/** Drill knobs (tests only): each makes the emulator disagree with one conformance claim. */
+type TodoistEmulatorDrills = {
+  /** `true`: a task-listing cursor leads back to the first page (tasks repeat across pages). */readonly cursorRestarts?: boolean; /** `true`: 404 bodies omit the `error` message. */
+  readonly notFoundWithoutError?: boolean; /** `true`: tasks answer their labels as label ids instead of names. */
+  readonly taskLabelsAsIds?: boolean; /** `true`: task listings include closed tasks. */
+  readonly listIncludesClosed?: boolean; /** `true`: `due_date` / `due_datetime` are accepted but not applied (`due` stays `null`). */
+  readonly ignoreDue?: boolean; /** `true`: a project create answers `parent_id: null` (the project still has its parent). */
+  readonly createOmitsParent?: boolean; /** `true`: deleting a project keeps its tasks. */
+  readonly deleteKeepsTasks?: boolean;
+};
+/** Where a task-listing cursor leads (runtime data, like the ledger; not in the state). */
+type TodoistCursor = {
+  readonly id: string;
+  readonly projectId: string;
+  readonly limit: string;
+  readonly offset: number;
+};
+type TodoistApiEnv = {
+  /** Clock in epoch milliseconds (timestamps of created and closed items). */readonly now: () => number;
+  readonly drills: Required<TodoistEmulatorDrills>; /** Task-listing cursors by id (runtime-only; cleared by reset and seed). */
+  readonly cursors: Map<string, TodoistCursor>;
+  readonly cursorCounter: {
+    next: number;
+  };
+};
+type TodoistApiRoute = {
+  readonly route: StatefulRoute<TodoistEmulatorState, TodoistApiEnv>; /** Query parameters the route emulates; any other (or a repeated) key is not emulated. */
+  readonly queryKeys: ReadonlyArray<string>;
+};
+/** The route table: evidence plus handler. `todoistEmulatorRoutes` is its evidence part. */
+declare const todoistApiRoutes: ReadonlyArray<TodoistApiRoute>;
+type TodoistMatchedRoute = {
+  readonly route: TodoistApiRoute; /** Path parameters (Todoist ids, matched raw: never percent-encoded). */
+  readonly params: Readonly<Record<string, string>>;
+};
+/**
+ * The route answering `method` + raw `path` with its id parameters, or `undefined` (no route, a
+ * reserved endpoint word, or a raw segment that is not a Todoist id: percent-encoding is never
+ * recognised).
+ */
+declare const matchTodoistRoute: (method: string, path: string) => TodoistMatchedRoute | undefined;
+/**
+ * Why the query is not emulated on `route` (a key it does not emulate, or a repeated key), or
+ * `undefined`.
+ */
+declare const todoistQueryProblem: (route: TodoistApiRoute, query: URLSearchParams) => string | undefined;
+//#endregion
+export { TodoistApiEnv, TodoistCursor, TodoistEmulatorDrills, TodoistMatchedRoute, matchTodoistRoute, todoistApiRoutes, todoistEmulatorBasePath, todoistQueryProblem };
+//# sourceMappingURL=api.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/todoist/api.ts"],"mappings":";;;;;cAuCa,uBAAA;AAAb;AAAA,KAGY,qBAAA;yGAED,cAAA,YALyB;EAAA,SAOzB,oBAAA,YAJsB;EAAA,SAMtB,eAAA,YANsB;EAAA,SAQtB,kBAAA,YAJA;EAAA,SAMA,SAAA,YAFA;EAAA,SAIA,iBAAA;EAAA,SAEA,gBAAA;AAAA;AAAgB;AAAA,KAIf,aAAA;EAAA,SACD,EAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;AAAA;AAAA,KAGC,aAAA;EAHD,qFAKA,GAAA;EAAA,SACA,MAAA,EAAQ,QAAA,CAAS,qBAAA,GAHhB;EAAA,SAKD,OAAA,EAAS,GAAA,SAAY,aAAA;EAAA,SACrB,aAAA;IAAiB,IAAA;EAAA;AAAA;AAAA,KAwBvB,eAAA;EAAA,SACM,KAAA,EAAO,aAAA,CAAc,oBAAA,EAAsB,aAAA,GA1B/B;EAAA,SA4BZ,SAAA,EAAW,aAAA;AAAA;;cAwhBT,gBAAA,EAAkB,aAAa,CAAC,eAAA;AAAA,KA4BjC,mBAAA;EAAA,SACD,KAAA,EAAO,eAAA,EAjlBc;EAAA,SAmlBrB,MAAA,EAAQ,QAAA,CAAS,MAAA;AAAA;;AAllBI;AAC/B;;;cAqmBY,iBAAA,GACX,MAAA,UACA,IAAA,aACC,mBAAmB;;;;;cA+BT,mBAAA,GACX,KAAA,EAAO,eAAA,EACP,KAAA,EAAO,eAAe"}