@agimon-ai/po-team 0.0.0-alpha.0

package/dist/apiContracts.mjs

@@ -0,0 +1,157 @@
+import { defineApiContract, jsonApiResponses } from "@agimon-ai/po-core/apiContracts";
+import { Type } from "typebox";
+//#region src/schemas/apiContracts.ts
+const S = Type.String();
+const N = Type.Number();
+const O = Type.Optional;
+const literals = (values) => Type.Union(values.map((value) => Type.Literal(value)));
+const TeamCatalogSchema = Type.Object({
+	cwd: S,
+	models: Type.Array(S),
+	warning: O(S),
+	agents: Type.Array(Type.Object({
+		name: S,
+		source: literals([
+			"project",
+			"user",
+			"plugin"
+		]),
+		packageName: O(S),
+		description: S,
+		model: O(S),
+		fallbackModels: Type.Array(S),
+		tools: Type.Array(S),
+		skills: Type.Array(S),
+		extensions: Type.Array(S),
+		defaultContext: literals(["fresh", "fork"]),
+		filePath: S
+	}))
+});
+const TeamRunsSchema = Type.Object({ runs: Type.Array(Type.Object({
+	runId: S,
+	agent: S,
+	state: literals([
+		"queued",
+		"running",
+		"done",
+		"failed",
+		"stopped"
+	]),
+	rawState: S,
+	task: S,
+	taskRef: O(S),
+	model: O(S),
+	cwd: S,
+	sessionFile: O(S),
+	startedAt: N,
+	endedAt: O(N),
+	lastUpdate: N,
+	currentTool: O(S),
+	toolCount: O(N),
+	tokens: O(N),
+	cost: O(N),
+	summary: O(S),
+	error: O(S),
+	tail: Type.Array(S)
+})) });
+const apiContracts = defineApiContract({
+	version: 1,
+	dynamic: [],
+	http: [
+		{
+			id: "team.catalog",
+			scope: "session",
+			basePath: "team",
+			path: "/catalog",
+			method: "GET",
+			authentication: "owner",
+			description: "Discover the active session agent catalog.",
+			responses: jsonApiResponses(TeamCatalogSchema)
+		},
+		{
+			id: "team.run",
+			scope: "session",
+			basePath: "team",
+			path: "/run",
+			method: "POST",
+			authentication: "owner",
+			description: "Launch an agent in the selected headless session.",
+			body: {
+				required: true,
+				contentType: "application/json",
+				schema: Type.Object({
+					agent: Type.String({ minLength: 1 }),
+					task: S,
+					fork: Type.Boolean(),
+					model: O(Type.String({ minLength: 1 }))
+				})
+			},
+			responses: jsonApiResponses(Type.Object({ runId: S }), 201)
+		},
+		{
+			id: "team.steer",
+			scope: "session",
+			basePath: "team",
+			path: "/steer",
+			method: "POST",
+			authentication: "owner",
+			description: "Send guidance straight to one running agent, without a parent prompt.",
+			body: {
+				required: true,
+				contentType: "application/json",
+				schema: Type.Object({
+					runId: Type.String({ minLength: 1 }),
+					message: Type.String({ minLength: 1 })
+				})
+			},
+			responses: jsonApiResponses(Type.Object({
+				requestId: S,
+				index: N,
+				state: literals([
+					"delivered",
+					"failed",
+					"pending"
+				]),
+				message: S
+			}))
+		},
+		{
+			id: "team.stop",
+			scope: "session",
+			basePath: "team",
+			path: "/stop",
+			method: "POST",
+			authentication: "owner",
+			description: "Ask the runtime to stop one running agent, without a parent prompt.",
+			body: {
+				required: true,
+				contentType: "application/json",
+				schema: Type.Object({ runId: Type.String({ minLength: 1 }) })
+			},
+			responses: jsonApiResponses(Type.Object({ requestId: S }))
+		}
+	],
+	sockets: ["global", "workspace"].flatMap((scope) => [{
+		id: "team.runs",
+		scope,
+		service: "po.hub.v1",
+		member: "subagent_runs",
+		kind: "channel",
+		direction: "server-to-client",
+		description: "Subagent run channel payload.",
+		input: TeamRunsSchema
+	}, {
+		id: "team.catalog.channel",
+		scope,
+		service: "po.hub.v1",
+		member: "subagent_catalog",
+		kind: "channel",
+		direction: "server-to-client",
+		description: "Subagent catalog channel payload.",
+		input: TeamCatalogSchema
+	}])
+});
+//#endregion
+export { apiContracts, apiContracts as default };
+
+//# sourceMappingURL=apiContracts.mjs.map

package/dist/apiContracts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiContracts.mjs","names":[],"sources":["../src/schemas/apiContracts.ts"],"sourcesContent":["import { defineApiContract, jsonApiResponses } from '@agimon-ai/po-core/apiContracts';\nimport { Type } from 'typebox';\n\nconst S = Type.String();\nconst N = Type.Number();\nconst O = Type.Optional;\nconst literals = <T extends string>(values: T[]) => Type.Union(values.map((value) => Type.Literal(value)));\nexport const TeamCatalogSchema = Type.Object({\n  cwd: S,\n  models: Type.Array(S),\n  warning: O(S),\n  agents: Type.Array(\n    Type.Object({\n      name: S,\n      source: literals(['project', 'user', 'plugin']),\n      packageName: O(S),\n      description: S,\n      model: O(S),\n      fallbackModels: Type.Array(S),\n      tools: Type.Array(S),\n      skills: Type.Array(S),\n      extensions: Type.Array(S),\n      defaultContext: literals(['fresh', 'fork']),\n      filePath: S,\n    }),\n  ),\n});\nexport const TeamRunsSchema = Type.Object({\n  runs: Type.Array(\n    Type.Object({\n      runId: S,\n      agent: S,\n      state: literals(['queued', 'running', 'done', 'failed', 'stopped']),\n      rawState: S,\n      task: S,\n      taskRef: O(S),\n      model: O(S),\n      cwd: S,\n      sessionFile: O(S),\n      startedAt: N,\n      endedAt: O(N),\n      lastUpdate: N,\n      currentTool: O(S),\n      toolCount: O(N),\n      tokens: O(N),\n      cost: O(N),\n      summary: O(S),\n      error: O(S),\n      tail: Type.Array(S),\n    }),\n  ),\n});\nexport const apiContracts = defineApiContract({\n  version: 1,\n  dynamic: [],\n  http: [\n    {\n      id: 'team.catalog',\n      scope: 'session',\n      basePath: 'team',\n      path: '/catalog',\n      method: 'GET',\n      authentication: 'owner',\n      description: 'Discover the active session agent catalog.',\n      responses: jsonApiResponses(TeamCatalogSchema),\n    },\n    {\n      id: 'team.run',\n      scope: 'session',\n      basePath: 'team',\n      path: '/run',\n      method: 'POST',\n      authentication: 'owner',\n      description: 'Launch an agent in the selected headless session.',\n      body: {\n        required: true,\n        contentType: 'application/json',\n        schema: Type.Object({\n          agent: Type.String({ minLength: 1 }),\n          task: S,\n          fork: Type.Boolean(),\n          model: O(Type.String({ minLength: 1 })),\n        }),\n      },\n      responses: jsonApiResponses(Type.Object({ runId: S }), 201),\n    },\n    {\n      id: 'team.steer',\n      scope: 'session',\n      basePath: 'team',\n      path: '/steer',\n      method: 'POST',\n      authentication: 'owner',\n      description: 'Send guidance straight to one running agent, without a parent prompt.',\n      body: {\n        required: true,\n        contentType: 'application/json',\n        schema: Type.Object({ runId: Type.String({ minLength: 1 }), message: Type.String({ minLength: 1 }) }),\n      },\n      responses: jsonApiResponses(\n        Type.Object({ requestId: S, index: N, state: literals(['delivered', 'failed', 'pending']), message: S }),\n      ),\n    },\n    {\n      id: 'team.stop',\n      scope: 'session',\n      basePath: 'team',\n      path: '/stop',\n      method: 'POST',\n      authentication: 'owner',\n      description: 'Ask the runtime to stop one running agent, without a parent prompt.',\n      body: {\n        required: true,\n        contentType: 'application/json',\n        schema: Type.Object({ runId: Type.String({ minLength: 1 }) }),\n      },\n      responses: jsonApiResponses(Type.Object({ requestId: S })),\n    },\n  ],\n  sockets: (['global', 'workspace'] as const).flatMap((scope) => [\n    {\n      id: 'team.runs',\n      scope,\n      service: 'po.hub.v1',\n      member: 'subagent_runs',\n      kind: 'channel',\n      direction: 'server-to-client',\n      description: 'Subagent run channel payload.',\n      input: TeamRunsSchema,\n    },\n    {\n      id: 'team.catalog.channel',\n      scope,\n      service: 'po.hub.v1',\n      member: 'subagent_catalog',\n      kind: 'channel',\n      direction: 'server-to-client',\n      description: 'Subagent catalog channel payload.',\n      input: TeamCatalogSchema,\n    },\n  ]),\n});\nexport default apiContracts;\n"],"mappings":"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"}

package/dist/atomicJson-D0346bt5.cjs

@@ -0,0 +1,178 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+//#region src/services/fileSystemRetry/index.ts
+/**
+* Retry helpers for transient filesystem failures.
+*
+* Windows holds brief directory and rename locks (antivirus, indexers, another
+* process reading the file), surfacing as EACCES, EBUSY or EPERM. Those clear on
+* their own, so the operation is retried on a backoff instead of failing a run.
+*
+* DESIGN PATTERNS:
+* - Two variants with the same policy: a synchronous one for the atomic writers
+*   that must not yield mid-write, and an async one for everything else
+*
+* AVOID:
+* - Reaching for the synchronous variant on a hot path; it blocks the event
+*   loop, and every millisecond of backoff is a millisecond the parent cannot
+*   service a child. Prefer `runFileSystemOperationWithRetryAsync`
+* - Retrying ENOENT or ENOTDIR; those are real errors, not contention
+*/
+const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : void 0;
+const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : void 0;
+const RETRYABLE_FILE_SYSTEM_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EBUSY",
+	"EPERM"
+]);
+const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [
+	10,
+	25,
+	50,
+	100,
+	200,
+	500,
+	1e3,
+	2e3,
+	4e3
+];
+/**
+* Block the current thread for `delayMs`.
+*
+* Only for synchronous callers that cannot yield. `Atomics.wait` parks the
+* thread rather than burning CPU; the loop below is a portable fallback for
+* runtimes without SharedArrayBuffer and does spin, which is why async callers
+* must use `delayForFileSystemRetry` instead.
+*/
+function waitForFileSystemRetry(delayMs) {
+	if (delayMs <= 0) return;
+	if (WAIT_VIEW) try {
+		Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
+		return;
+	} catch {}
+	const end = Date.now() + delayMs;
+	while (Date.now() < end);
+}
+function isRetryableFileSystemError(error) {
+	const code = error?.code;
+	return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
+}
+function runFileSystemOperationWithRetry(operation, options = {}) {
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const wait = options.wait ?? waitForFileSystemRetry;
+	for (let attempt = 0;; attempt++) try {
+		return operation();
+	} catch (error) {
+		const delayMs = retryDelaysMs[attempt];
+		if (delayMs === void 0 || !isRetryableFileSystemError(error)) throw error;
+		wait(delayMs);
+	}
+}
+//#endregion
+//#region src/services/atomicJson/index.ts
+/**
+* Atomic JSON writes.
+*
+* DESIGN PATTERNS:
+* - Write to a uniquely named temp file in the destination directory, then
+*   rename onto the target. Rename is atomic within a filesystem, so a reader
+*   sees either the previous file or the complete new one, never a partial write
+* - The temp name carries pid, timestamp and a random suffix so two processes
+*   writing the same target never collide on the temp file
+*
+* WHAT THIS DOES NOT DO:
+* This prevents torn reads. It does NOT prevent lost updates: two writers doing
+* read-modify-write still clobber each other, because the rename only publishes
+* whatever the caller already computed. Anything needing mutual exclusion has to
+* take a lease or claim, not rely on atomic writes.
+*
+* AVOID:
+* - Treating this as a lock
+* - Using the plain writer for anything sensitive; prefer writePrivateAtomicJson,
+*   which creates the file 0600 so a shared temp directory does not leak prompts
+*/
+const PRIVATE_FILE_MODE = 384;
+const JSON_INDENT = 2;
+function createAtomicJsonWriter(options = {}) {
+	const fsImpl = options.fs ?? node_fs;
+	const now = options.now ?? Date.now;
+	const pid = options.pid ?? process.pid;
+	const random = options.random ?? Math.random;
+	const mode = options.mode;
+	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+	const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
+	const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
+	const wait = options.wait ?? waitForFileSystemRetry;
+	return (filePath, payload) => {
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.mkdirSync(node_path.dirname(filePath), { recursive: true });
+		}, {
+			retryDelaysMs: directoryRetryDelaysMs,
+			wait
+		});
+		const tempPath = node_path.join(node_path.dirname(filePath), `.${node_path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`);
+		try {
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, JSON_INDENT), mode === void 0 ? "utf-8" : {
+				encoding: "utf-8",
+				mode
+			});
+			runFileSystemOperationWithRetry(() => {
+				fsImpl.renameSync(tempPath, filePath);
+			}, {
+				retryDelaysMs: renameRetryDelaysMs,
+				wait
+			});
+		} finally {
+			fsImpl.rmSync(tempPath, { force: true });
+		}
+	};
+}
+const writeAtomicJson = createAtomicJsonWriter();
+const writePrivateAtomicJson = createAtomicJsonWriter({ mode: PRIVATE_FILE_MODE });
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "writeAtomicJson", {
+	enumerable: true,
+	get: function() {
+		return writeAtomicJson;
+	}
+});
+Object.defineProperty(exports, "writePrivateAtomicJson", {
+	enumerable: true,
+	get: function() {
+		return writePrivateAtomicJson;
+	}
+});
+
+//# sourceMappingURL=atomicJson-D0346bt5.cjs.map

package/dist/atomicJson-D0346bt5.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomicJson-D0346bt5.cjs","names":["fs","path"],"sources":["../src/services/fileSystemRetry/index.ts","../src/services/atomicJson/index.ts"],"sourcesContent":["/**\n * Retry helpers for transient filesystem failures.\n *\n * Windows holds brief directory and rename locks (antivirus, indexers, another\n * process reading the file), surfacing as EACCES, EBUSY or EPERM. Those clear on\n * their own, so the operation is retried on a backoff instead of failing a run.\n *\n * DESIGN PATTERNS:\n * - Two variants with the same policy: a synchronous one for the atomic writers\n *   that must not yield mid-write, and an async one for everything else\n *\n * AVOID:\n * - Reaching for the synchronous variant on a hot path; it blocks the event\n *   loop, and every millisecond of backoff is a millisecond the parent cannot\n *   service a child. Prefer `runFileSystemOperationWithRetryAsync`\n * - Retrying ENOENT or ENOTDIR; those are real errors, not contention\n */\n\nconst WAIT_BUFFER = typeof SharedArrayBuffer !== 'undefined' ? new SharedArrayBuffer(4) : undefined;\nconst WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;\nconst RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);\n\nexport const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;\n\nexport type FileSystemRetryOptions = {\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => void;\n};\n\nexport type AsyncFileSystemRetryOptions = {\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => Promise<void>;\n};\n\n/**\n * Block the current thread for `delayMs`.\n *\n * Only for synchronous callers that cannot yield. `Atomics.wait` parks the\n * thread rather than burning CPU; the loop below is a portable fallback for\n * runtimes without SharedArrayBuffer and does spin, which is why async callers\n * must use `delayForFileSystemRetry` instead.\n */\nexport function waitForFileSystemRetry(delayMs: number): void {\n  if (delayMs <= 0) return;\n  if (WAIT_VIEW) {\n    try {\n      Atomics.wait(WAIT_VIEW, 0, 0, delayMs);\n      return;\n    } catch {\n      // Fall through to the portable busy wait below.\n    }\n  }\n  const end = Date.now() + delayMs;\n  while (Date.now() < end) {\n    // Portable fallback for runtimes where Atomics.wait is unavailable.\n  }\n}\n\n/** Yield for `delayMs` without blocking the event loop. */\nexport function delayForFileSystemRetry(delayMs: number): Promise<void> {\n  if (delayMs <= 0) return Promise.resolve();\n  return new Promise((resolve) => {\n    setTimeout(resolve, delayMs);\n  });\n}\n\nexport function isRetryableFileSystemError(error: unknown): boolean {\n  const code = (error as NodeJS.ErrnoException | undefined)?.code;\n  return typeof code === 'string' && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);\n}\n\nexport function runFileSystemOperationWithRetry<T>(operation: () => T, options: FileSystemRetryOptions = {}): T {\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const wait = options.wait ?? waitForFileSystemRetry;\n  for (let attempt = 0; ; attempt++) {\n    try {\n      return operation();\n    } catch (error) {\n      const delayMs = retryDelaysMs[attempt];\n      if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;\n      wait(delayMs);\n    }\n  }\n}\n\nexport async function runFileSystemOperationWithRetryAsync<T>(\n  operation: () => T | Promise<T>,\n  options: AsyncFileSystemRetryOptions = {},\n): Promise<T> {\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const wait = options.wait ?? delayForFileSystemRetry;\n  for (let attempt = 0; ; attempt++) {\n    try {\n      return await operation();\n    } catch (error) {\n      const delayMs = retryDelaysMs[attempt];\n      if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;\n      await wait(delayMs);\n    }\n  }\n}\n","/**\n * Atomic JSON writes.\n *\n * DESIGN PATTERNS:\n * - Write to a uniquely named temp file in the destination directory, then\n *   rename onto the target. Rename is atomic within a filesystem, so a reader\n *   sees either the previous file or the complete new one, never a partial write\n * - The temp name carries pid, timestamp and a random suffix so two processes\n *   writing the same target never collide on the temp file\n *\n * WHAT THIS DOES NOT DO:\n * This prevents torn reads. It does NOT prevent lost updates: two writers doing\n * read-modify-write still clobber each other, because the rename only publishes\n * whatever the caller already computed. Anything needing mutual exclusion has to\n * take a lease or claim, not rely on atomic writes.\n *\n * AVOID:\n * - Treating this as a lock\n * - Using the plain writer for anything sensitive; prefer writePrivateAtomicJson,\n *   which creates the file 0600 so a shared temp directory does not leak prompts\n */\n\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\n\nimport {\n  DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,\n  runFileSystemOperationWithRetry,\n  runFileSystemOperationWithRetryAsync,\n  waitForFileSystemRetry,\n} from '../fileSystemRetry';\n\nconst PRIVATE_FILE_MODE = 0o600;\nconst JSON_INDENT = 2;\n\ntype AtomicJsonFs = Pick<typeof fs, 'mkdirSync' | 'writeFileSync' | 'renameSync' | 'rmSync'>;\n\ntype AtomicJsonWriterOptions = {\n  fs?: AtomicJsonFs;\n  now?: () => number;\n  pid?: number;\n  random?: () => number;\n  mode?: number;\n  retryRenameErrors?: boolean;\n  retryDirectoryErrors?: boolean;\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => void;\n};\n\nexport function createAtomicJsonWriter(\n  options: AtomicJsonWriterOptions = {},\n): (filePath: string, payload: object) => void {\n  const fsImpl = options.fs ?? fs;\n  const now = options.now ?? Date.now;\n  const pid = options.pid ?? process.pid;\n  const random = options.random ?? Math.random;\n  const mode = options.mode;\n  // Retries exist for Windows directory and rename locks; other platforms fail fast.\n  const retryRenameErrors = options.retryRenameErrors ?? process.platform === 'win32';\n  const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];\n  const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];\n  const wait = options.wait ?? waitForFileSystemRetry;\n\n  return (filePath: string, payload: object): void => {\n    runFileSystemOperationWithRetry(\n      () => {\n        fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });\n      },\n      { retryDelaysMs: directoryRetryDelaysMs, wait },\n    );\n    const tempPath = path.join(\n      path.dirname(filePath),\n      `.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,\n    );\n    try {\n      fsImpl.writeFileSync(\n        tempPath,\n        JSON.stringify(payload, null, JSON_INDENT),\n        mode === undefined ? 'utf-8' : { encoding: 'utf-8', mode },\n      );\n      runFileSystemOperationWithRetry(\n        () => {\n          fsImpl.renameSync(tempPath, filePath);\n        },\n        { retryDelaysMs: renameRetryDelaysMs, wait },\n      );\n    } finally {\n      // Best effort: on the happy path the rename already consumed the temp file.\n      fsImpl.rmSync(tempPath, { force: true });\n    }\n  };\n}\n\nexport const writeAtomicJson = createAtomicJsonWriter();\nexport const writePrivateAtomicJson = createAtomicJsonWriter({ mode: PRIVATE_FILE_MODE });\n\n/** Promise-based atomic writer for startup, polling, and other non-critical paths. */\nexport async function writeAtomicJsonAsync(filePath: string, payload: object, mode?: number): Promise<void> {\n  const retryDelaysMs = process.platform === 'win32' ? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];\n  await runFileSystemOperationWithRetryAsync(() => fs.promises.mkdir(path.dirname(filePath), { recursive: true }), {\n    retryDelaysMs,\n  });\n  const tempPath = path.join(\n    path.dirname(filePath),\n    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,\n  );\n  try {\n    await fs.promises.writeFile(\n      tempPath,\n      JSON.stringify(payload, null, JSON_INDENT),\n      mode === undefined ? 'utf-8' : { encoding: 'utf-8', mode },\n    );\n    await runFileSystemOperationWithRetryAsync(() => fs.promises.rename(tempPath, filePath), { retryDelaysMs });\n  } finally {\n    await fs.promises.rm(tempPath, { force: true });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,MAAM,cAAc,OAAO,sBAAsB,cAAc,IAAI,kBAAkB,CAAC,IAAI,KAAA;AAC1F,MAAM,YAAY,cAAc,IAAI,WAAW,WAAW,IAAI,KAAA;AAC9D,MAAM,oDAAoC,IAAI,IAAI;CAAC;CAAU;CAAS;AAAO,CAAC;AAE9E,MAAa,sCAAsC;CAAC;CAAI;CAAI;CAAI;CAAK;CAAK;CAAK;CAAM;CAAM;AAAI;;;;;;;;;AAoB/F,SAAgB,uBAAuB,SAAuB;CAC5D,IAAI,WAAW,GAAG;CAClB,IAAI,WACF,IAAI;EACF,QAAQ,KAAK,WAAW,GAAG,GAAG,OAAO;EACrC;CACF,QAAQ,CAER;CAEF,MAAM,MAAM,KAAK,IAAI,IAAI;CACzB,OAAO,KAAK,IAAI,IAAI;AAGtB;AAUA,SAAgB,2BAA2B,OAAyB;CAClE,MAAM,OAAQ,OAA6C;CAC3D,OAAO,OAAO,SAAS,YAAY,kCAAkC,IAAI,IAAI;AAC/E;AAEA,SAAgB,gCAAmC,WAAoB,UAAkC,CAAC,GAAM;CAC9G,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,OAAO,QAAQ,QAAQ;CAC7B,KAAK,IAAI,UAAU,IAAK,WACtB,IAAI;EACF,OAAO,UAAU;CACnB,SAAS,OAAO;EACd,MAAM,UAAU,cAAc;EAC9B,IAAI,YAAY,KAAA,KAAa,CAAC,2BAA2B,KAAK,GAAG,MAAM;EACvE,KAAK,OAAO;CACd;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;ACnDA,MAAM,oBAAoB;AAC1B,MAAM,cAAc;AAgBpB,SAAgB,uBACd,UAAmC,CAAC,GACS;CAC7C,MAAM,SAAS,QAAQ,MAAMA;CAC7B,MAAM,MAAM,QAAQ,OAAO,KAAK;CAChC,MAAM,MAAM,QAAQ,OAAO,QAAQ;CACnC,MAAM,SAAS,QAAQ,UAAU,KAAK;CACtC,MAAM,OAAO,QAAQ;CAErB,MAAM,oBAAoB,QAAQ,qBAAqB,QAAQ,aAAa;CAC5E,MAAM,uBAAuB,QAAQ,wBAAwB;CAC7D,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,sBAAsB,oBAAoB,gBAAgB,CAAC;CACjE,MAAM,yBAAyB,uBAAuB,gBAAgB,CAAC;CACvE,MAAM,OAAO,QAAQ,QAAQ;CAE7B,QAAQ,UAAkB,YAA0B;EAClD,sCACQ;GACJ,OAAO,UAAUC,UAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;EAC9D,GACA;GAAE,eAAe;GAAwB;EAAK,CAChD;EACA,MAAM,WAAWA,UAAK,KACpBA,UAAK,QAAQ,QAAQ,GACrB,IAAIA,UAAK,SAAS,QAAQ,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,KAChF;EACA,IAAI;GACF,OAAO,cACL,UACA,KAAK,UAAU,SAAS,MAAM,WAAW,GACzC,SAAS,KAAA,IAAY,UAAU;IAAE,UAAU;IAAS;GAAK,CAC3D;GACA,sCACQ;IACJ,OAAO,WAAW,UAAU,QAAQ;GACtC,GACA;IAAE,eAAe;IAAqB;GAAK,CAC7C;EACF,UAAU;GAER,OAAO,OAAO,UAAU,EAAE,OAAO,KAAK,CAAC;EACzC;CACF;AACF;AAEA,MAAa,kBAAkB,uBAAuB;AACtD,MAAa,yBAAyB,uBAAuB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/atomicJson-D2t0CDh9.mjs

@@ -0,0 +1,137 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+//#region src/services/fileSystemRetry/index.ts
+/**
+* Retry helpers for transient filesystem failures.
+*
+* Windows holds brief directory and rename locks (antivirus, indexers, another
+* process reading the file), surfacing as EACCES, EBUSY or EPERM. Those clear on
+* their own, so the operation is retried on a backoff instead of failing a run.
+*
+* DESIGN PATTERNS:
+* - Two variants with the same policy: a synchronous one for the atomic writers
+*   that must not yield mid-write, and an async one for everything else
+*
+* AVOID:
+* - Reaching for the synchronous variant on a hot path; it blocks the event
+*   loop, and every millisecond of backoff is a millisecond the parent cannot
+*   service a child. Prefer `runFileSystemOperationWithRetryAsync`
+* - Retrying ENOENT or ENOTDIR; those are real errors, not contention
+*/
+const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : void 0;
+const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : void 0;
+const RETRYABLE_FILE_SYSTEM_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EBUSY",
+	"EPERM"
+]);
+const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [
+	10,
+	25,
+	50,
+	100,
+	200,
+	500,
+	1e3,
+	2e3,
+	4e3
+];
+/**
+* Block the current thread for `delayMs`.
+*
+* Only for synchronous callers that cannot yield. `Atomics.wait` parks the
+* thread rather than burning CPU; the loop below is a portable fallback for
+* runtimes without SharedArrayBuffer and does spin, which is why async callers
+* must use `delayForFileSystemRetry` instead.
+*/
+function waitForFileSystemRetry(delayMs) {
+	if (delayMs <= 0) return;
+	if (WAIT_VIEW) try {
+		Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
+		return;
+	} catch {}
+	const end = Date.now() + delayMs;
+	while (Date.now() < end);
+}
+function isRetryableFileSystemError(error) {
+	const code = error?.code;
+	return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
+}
+function runFileSystemOperationWithRetry(operation, options = {}) {
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const wait = options.wait ?? waitForFileSystemRetry;
+	for (let attempt = 0;; attempt++) try {
+		return operation();
+	} catch (error) {
+		const delayMs = retryDelaysMs[attempt];
+		if (delayMs === void 0 || !isRetryableFileSystemError(error)) throw error;
+		wait(delayMs);
+	}
+}
+//#endregion
+//#region src/services/atomicJson/index.ts
+/**
+* Atomic JSON writes.
+*
+* DESIGN PATTERNS:
+* - Write to a uniquely named temp file in the destination directory, then
+*   rename onto the target. Rename is atomic within a filesystem, so a reader
+*   sees either the previous file or the complete new one, never a partial write
+* - The temp name carries pid, timestamp and a random suffix so two processes
+*   writing the same target never collide on the temp file
+*
+* WHAT THIS DOES NOT DO:
+* This prevents torn reads. It does NOT prevent lost updates: two writers doing
+* read-modify-write still clobber each other, because the rename only publishes
+* whatever the caller already computed. Anything needing mutual exclusion has to
+* take a lease or claim, not rely on atomic writes.
+*
+* AVOID:
+* - Treating this as a lock
+* - Using the plain writer for anything sensitive; prefer writePrivateAtomicJson,
+*   which creates the file 0600 so a shared temp directory does not leak prompts
+*/
+const PRIVATE_FILE_MODE = 384;
+const JSON_INDENT = 2;
+function createAtomicJsonWriter(options = {}) {
+	const fsImpl = options.fs ?? fs;
+	const now = options.now ?? Date.now;
+	const pid = options.pid ?? process.pid;
+	const random = options.random ?? Math.random;
+	const mode = options.mode;
+	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+	const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
+	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
+	const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
+	const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
+	const wait = options.wait ?? waitForFileSystemRetry;
+	return (filePath, payload) => {
+		runFileSystemOperationWithRetry(() => {
+			fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		}, {
+			retryDelaysMs: directoryRetryDelaysMs,
+			wait
+		});
+		const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`);
+		try {
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, JSON_INDENT), mode === void 0 ? "utf-8" : {
+				encoding: "utf-8",
+				mode
+			});
+			runFileSystemOperationWithRetry(() => {
+				fsImpl.renameSync(tempPath, filePath);
+			}, {
+				retryDelaysMs: renameRetryDelaysMs,
+				wait
+			});
+		} finally {
+			fsImpl.rmSync(tempPath, { force: true });
+		}
+	};
+}
+const writeAtomicJson = createAtomicJsonWriter();
+const writePrivateAtomicJson = createAtomicJsonWriter({ mode: PRIVATE_FILE_MODE });
+//#endregion
+export { writePrivateAtomicJson as n, writeAtomicJson as t };
+
+//# sourceMappingURL=atomicJson-D2t0CDh9.mjs.map

package/dist/atomicJson-D2t0CDh9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomicJson-D2t0CDh9.mjs","names":[],"sources":["../src/services/fileSystemRetry/index.ts","../src/services/atomicJson/index.ts"],"sourcesContent":["/**\n * Retry helpers for transient filesystem failures.\n *\n * Windows holds brief directory and rename locks (antivirus, indexers, another\n * process reading the file), surfacing as EACCES, EBUSY or EPERM. Those clear on\n * their own, so the operation is retried on a backoff instead of failing a run.\n *\n * DESIGN PATTERNS:\n * - Two variants with the same policy: a synchronous one for the atomic writers\n *   that must not yield mid-write, and an async one for everything else\n *\n * AVOID:\n * - Reaching for the synchronous variant on a hot path; it blocks the event\n *   loop, and every millisecond of backoff is a millisecond the parent cannot\n *   service a child. Prefer `runFileSystemOperationWithRetryAsync`\n * - Retrying ENOENT or ENOTDIR; those are real errors, not contention\n */\n\nconst WAIT_BUFFER = typeof SharedArrayBuffer !== 'undefined' ? new SharedArrayBuffer(4) : undefined;\nconst WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;\nconst RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);\n\nexport const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;\n\nexport type FileSystemRetryOptions = {\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => void;\n};\n\nexport type AsyncFileSystemRetryOptions = {\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => Promise<void>;\n};\n\n/**\n * Block the current thread for `delayMs`.\n *\n * Only for synchronous callers that cannot yield. `Atomics.wait` parks the\n * thread rather than burning CPU; the loop below is a portable fallback for\n * runtimes without SharedArrayBuffer and does spin, which is why async callers\n * must use `delayForFileSystemRetry` instead.\n */\nexport function waitForFileSystemRetry(delayMs: number): void {\n  if (delayMs <= 0) return;\n  if (WAIT_VIEW) {\n    try {\n      Atomics.wait(WAIT_VIEW, 0, 0, delayMs);\n      return;\n    } catch {\n      // Fall through to the portable busy wait below.\n    }\n  }\n  const end = Date.now() + delayMs;\n  while (Date.now() < end) {\n    // Portable fallback for runtimes where Atomics.wait is unavailable.\n  }\n}\n\n/** Yield for `delayMs` without blocking the event loop. */\nexport function delayForFileSystemRetry(delayMs: number): Promise<void> {\n  if (delayMs <= 0) return Promise.resolve();\n  return new Promise((resolve) => {\n    setTimeout(resolve, delayMs);\n  });\n}\n\nexport function isRetryableFileSystemError(error: unknown): boolean {\n  const code = (error as NodeJS.ErrnoException | undefined)?.code;\n  return typeof code === 'string' && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);\n}\n\nexport function runFileSystemOperationWithRetry<T>(operation: () => T, options: FileSystemRetryOptions = {}): T {\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const wait = options.wait ?? waitForFileSystemRetry;\n  for (let attempt = 0; ; attempt++) {\n    try {\n      return operation();\n    } catch (error) {\n      const delayMs = retryDelaysMs[attempt];\n      if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;\n      wait(delayMs);\n    }\n  }\n}\n\nexport async function runFileSystemOperationWithRetryAsync<T>(\n  operation: () => T | Promise<T>,\n  options: AsyncFileSystemRetryOptions = {},\n): Promise<T> {\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const wait = options.wait ?? delayForFileSystemRetry;\n  for (let attempt = 0; ; attempt++) {\n    try {\n      return await operation();\n    } catch (error) {\n      const delayMs = retryDelaysMs[attempt];\n      if (delayMs === undefined || !isRetryableFileSystemError(error)) throw error;\n      await wait(delayMs);\n    }\n  }\n}\n","/**\n * Atomic JSON writes.\n *\n * DESIGN PATTERNS:\n * - Write to a uniquely named temp file in the destination directory, then\n *   rename onto the target. Rename is atomic within a filesystem, so a reader\n *   sees either the previous file or the complete new one, never a partial write\n * - The temp name carries pid, timestamp and a random suffix so two processes\n *   writing the same target never collide on the temp file\n *\n * WHAT THIS DOES NOT DO:\n * This prevents torn reads. It does NOT prevent lost updates: two writers doing\n * read-modify-write still clobber each other, because the rename only publishes\n * whatever the caller already computed. Anything needing mutual exclusion has to\n * take a lease or claim, not rely on atomic writes.\n *\n * AVOID:\n * - Treating this as a lock\n * - Using the plain writer for anything sensitive; prefer writePrivateAtomicJson,\n *   which creates the file 0600 so a shared temp directory does not leak prompts\n */\n\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\n\nimport {\n  DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,\n  runFileSystemOperationWithRetry,\n  runFileSystemOperationWithRetryAsync,\n  waitForFileSystemRetry,\n} from '../fileSystemRetry';\n\nconst PRIVATE_FILE_MODE = 0o600;\nconst JSON_INDENT = 2;\n\ntype AtomicJsonFs = Pick<typeof fs, 'mkdirSync' | 'writeFileSync' | 'renameSync' | 'rmSync'>;\n\ntype AtomicJsonWriterOptions = {\n  fs?: AtomicJsonFs;\n  now?: () => number;\n  pid?: number;\n  random?: () => number;\n  mode?: number;\n  retryRenameErrors?: boolean;\n  retryDirectoryErrors?: boolean;\n  retryDelaysMs?: readonly number[];\n  wait?: (delayMs: number) => void;\n};\n\nexport function createAtomicJsonWriter(\n  options: AtomicJsonWriterOptions = {},\n): (filePath: string, payload: object) => void {\n  const fsImpl = options.fs ?? fs;\n  const now = options.now ?? Date.now;\n  const pid = options.pid ?? process.pid;\n  const random = options.random ?? Math.random;\n  const mode = options.mode;\n  // Retries exist for Windows directory and rename locks; other platforms fail fast.\n  const retryRenameErrors = options.retryRenameErrors ?? process.platform === 'win32';\n  const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;\n  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;\n  const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];\n  const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];\n  const wait = options.wait ?? waitForFileSystemRetry;\n\n  return (filePath: string, payload: object): void => {\n    runFileSystemOperationWithRetry(\n      () => {\n        fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });\n      },\n      { retryDelaysMs: directoryRetryDelaysMs, wait },\n    );\n    const tempPath = path.join(\n      path.dirname(filePath),\n      `.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,\n    );\n    try {\n      fsImpl.writeFileSync(\n        tempPath,\n        JSON.stringify(payload, null, JSON_INDENT),\n        mode === undefined ? 'utf-8' : { encoding: 'utf-8', mode },\n      );\n      runFileSystemOperationWithRetry(\n        () => {\n          fsImpl.renameSync(tempPath, filePath);\n        },\n        { retryDelaysMs: renameRetryDelaysMs, wait },\n      );\n    } finally {\n      // Best effort: on the happy path the rename already consumed the temp file.\n      fsImpl.rmSync(tempPath, { force: true });\n    }\n  };\n}\n\nexport const writeAtomicJson = createAtomicJsonWriter();\nexport const writePrivateAtomicJson = createAtomicJsonWriter({ mode: PRIVATE_FILE_MODE });\n\n/** Promise-based atomic writer for startup, polling, and other non-critical paths. */\nexport async function writeAtomicJsonAsync(filePath: string, payload: object, mode?: number): Promise<void> {\n  const retryDelaysMs = process.platform === 'win32' ? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];\n  await runFileSystemOperationWithRetryAsync(() => fs.promises.mkdir(path.dirname(filePath), { recursive: true }), {\n    retryDelaysMs,\n  });\n  const tempPath = path.join(\n    path.dirname(filePath),\n    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,\n  );\n  try {\n    await fs.promises.writeFile(\n      tempPath,\n      JSON.stringify(payload, null, JSON_INDENT),\n      mode === undefined ? 'utf-8' : { encoding: 'utf-8', mode },\n    );\n    await runFileSystemOperationWithRetryAsync(() => fs.promises.rename(tempPath, filePath), { retryDelaysMs });\n  } finally {\n    await fs.promises.rm(tempPath, { force: true });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBA,MAAM,cAAc,OAAO,sBAAsB,cAAc,IAAI,kBAAkB,CAAC,IAAI,KAAA;AAC1F,MAAM,YAAY,cAAc,IAAI,WAAW,WAAW,IAAI,KAAA;AAC9D,MAAM,oDAAoC,IAAI,IAAI;CAAC;CAAU;CAAS;AAAO,CAAC;AAE9E,MAAa,sCAAsC;CAAC;CAAI;CAAI;CAAI;CAAK;CAAK;CAAK;CAAM;CAAM;AAAI;;;;;;;;;AAoB/F,SAAgB,uBAAuB,SAAuB;CAC5D,IAAI,WAAW,GAAG;CAClB,IAAI,WACF,IAAI;EACF,QAAQ,KAAK,WAAW,GAAG,GAAG,OAAO;EACrC;CACF,QAAQ,CAER;CAEF,MAAM,MAAM,KAAK,IAAI,IAAI;CACzB,OAAO,KAAK,IAAI,IAAI;AAGtB;AAUA,SAAgB,2BAA2B,OAAyB;CAClE,MAAM,OAAQ,OAA6C;CAC3D,OAAO,OAAO,SAAS,YAAY,kCAAkC,IAAI,IAAI;AAC/E;AAEA,SAAgB,gCAAmC,WAAoB,UAAkC,CAAC,GAAM;CAC9G,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,OAAO,QAAQ,QAAQ;CAC7B,KAAK,IAAI,UAAU,IAAK,WACtB,IAAI;EACF,OAAO,UAAU;CACnB,SAAS,OAAO;EACd,MAAM,UAAU,cAAc;EAC9B,IAAI,YAAY,KAAA,KAAa,CAAC,2BAA2B,KAAK,GAAG,MAAM;EACvE,KAAK,OAAO;CACd;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;ACnDA,MAAM,oBAAoB;AAC1B,MAAM,cAAc;AAgBpB,SAAgB,uBACd,UAAmC,CAAC,GACS;CAC7C,MAAM,SAAS,QAAQ,MAAM;CAC7B,MAAM,MAAM,QAAQ,OAAO,KAAK;CAChC,MAAM,MAAM,QAAQ,OAAO,QAAQ;CACnC,MAAM,SAAS,QAAQ,UAAU,KAAK;CACtC,MAAM,OAAO,QAAQ;CAErB,MAAM,oBAAoB,QAAQ,qBAAqB,QAAQ,aAAa;CAC5E,MAAM,uBAAuB,QAAQ,wBAAwB;CAC7D,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,sBAAsB,oBAAoB,gBAAgB,CAAC;CACjE,MAAM,yBAAyB,uBAAuB,gBAAgB,CAAC;CACvE,MAAM,OAAO,QAAQ,QAAQ;CAE7B,QAAQ,UAAkB,YAA0B;EAClD,sCACQ;GACJ,OAAO,UAAU,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;EAC9D,GACA;GAAE,eAAe;GAAwB;EAAK,CAChD;EACA,MAAM,WAAW,KAAK,KACpB,KAAK,QAAQ,QAAQ,GACrB,IAAI,KAAK,SAAS,QAAQ,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,KAChF;EACA,IAAI;GACF,OAAO,cACL,UACA,KAAK,UAAU,SAAS,MAAM,WAAW,GACzC,SAAS,KAAA,IAAY,UAAU;IAAE,UAAU;IAAS;GAAK,CAC3D;GACA,sCACQ;IACJ,OAAO,WAAW,UAAU,QAAQ;GACtC,GACA;IAAE,eAAe;IAAqB;GAAK,CAC7C;EACF,UAAU;GAER,OAAO,OAAO,UAAU,EAAE,OAAO,KAAK,CAAC;EACzC;CACF;AACF;AAEA,MAAa,kBAAkB,uBAAuB;AACtD,MAAa,yBAAyB,uBAAuB,EAAE,MAAM,kBAAkB,CAAC"}