@trebired/code-server-kit 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -4,6 +4,14 @@
 
 - nothing yet
 
+## 0.3.0
+
+- expand the package from launch planning into a full generic `code-server` session runtime
+- add session lifecycle APIs for start, stop, restart, status, diagnostics, and session-manager creation
+- add Linux-first transient systemd helpers and launch-command builders
+- add disk-backed session metadata, reuse checks, profile restore and persist hooks, and richer startup diagnostics
+- add `@trebired/logger-adapter` support across the higher-level APIs
+
 ## 0.2.0
 
 - add `createCodeServerLaunchPlan()` as the main higher-level launch planning API

package/README.md

@@ -1,19 +1,17 @@
 # @trebired/code-server-kit
 
-Framework-agnostic `code-server` integration helpers for Node.js applications.
+Framework-agnostic `code-server` session runtime for Node.js applications.
 
-`@trebired/code-server-kit` gives host applications a typed, generic layer for resolving an installed `code-server`, building a complete launch plan, waiting for readiness, syncing selected profile data, and preparing the result for direct processes, systemd units, containers, or custom sandboxes.
+`@trebired/code-server-kit` is the generic Trebired package for owning the full `code-server` lifecycle on Linux-first hosts:
 
-The package stays in one lane:
+- resolve the installed `code-server`
+- build launch plans and sandbox-friendly execution specs
+- restore and persist allowlisted profile data
+- launch directly or through transient systemd services
+- supervise readiness and startup failures
+- reuse, stop, restart, and inspect sessions with structured metadata
 
-- resolve the installed `code-server` package root and launch entrypoint
-- describe the final launch command, args, cwd, env, and path-access suggestions
-- expose structured errors that host apps can log and branch on
-- optionally spawn the process and wait for readiness
-- sync allowlisted profile data without copying a whole runtime tree
-- help reverse-proxy integrations with trusted-origin and forwarded-header helpers
-
-It does not try to be a `code-server` fork, a sandbox manager, a container runtime, or a product layer with app-specific routes and filesystem rules.
+The package stays generic on purpose. It does not know about products, repositories, organizations, users, routes, or app-specific filesystem conventions.
 
 ## Install
 
@@ -23,106 +21,163 @@ Runtime target: Node.js 22+ on Linux first.
 npm install @trebired/code-server-kit code-server
 ```
 
+## What Host Apps Still Provide
+
+After the session runtime layer is in place, host applications mostly choose policy:
+
+- `sessionKey`
+- `stateRoot`
+- `workspacePath`
+- `trustedOrigins`
+- `launchStrategy`
+- systemd `scope` when using systemd
+- optional profile roots
+- optional logging and policy hooks
+
+The package owns the generic mechanics:
+
+- installation resolution
+- entrypoint resolution
+- `node <entry.js>` vs direct executable launch
+- runtime profile directory defaults
+- direct launch vs systemd launch translation
+- readiness probing
+- session reuse checks
+- session metadata persistence
+- startup diagnostics normalization
+
 ## Quick Start
 
 ```ts
 import {
-  createCodeServerLaunchPlan,
-  launchCodeServerProcess,
-  waitForCodeServerReady,
+  createCodeServerSessionManager,
 } from "@trebired/code-server-kit";
 
-const plan = await createCodeServerLaunchPlan({
-  dataRoot: "/srv/code-server/session-42",
-  host: "127.0.0.1",
-  port: 8080,
+const sessions = createCodeServerSessionManager({
+  logger: console,
+});
+
+const started = await sessions.start({
+  launchStrategy: "direct",
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
   trustedOrigins: [
     "https://app.example.com",
   ],
   workspacePath: "/srv/workspaces/demo",
 });
 
-const handle = await launchCodeServerProcess({
-  plan,
-  stdout(text) {
-    process.stdout.write(text);
-  },
-  stderr(text) {
-    process.stderr.write(text);
-  },
+console.log(started.status.state, started.status.port);
+
+const status = await sessions.getStatus({
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
 });
 
-await waitForCodeServerReady({
-  host: plan.host,
-  port: plan.port,
-  process: handle,
-  timeoutMs: 30_000,
+console.log(status?.ready);
+
+await sessions.stop({
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
 });
 ```
 
-## Why The Launch Plan Exists
+## Main Session APIs
 
-Most host apps do not want to know where `code-server` put its real entry file, when to call `node <entry.js>` versus a direct executable, which package directories should be mounted read-only, or which runtime paths must stay writable.
+### `createCodeServerSessionManager(options?)`
 
-`createCodeServerLaunchPlan()` moves that generic integration work into one reusable contract so host apps can focus on policy instead:
+Creates the main high-level lifecycle object and wires logging through `@trebired/logger-adapter`.
 
-- what workspace should be opened
-- which paths should actually be writable in a sandbox
-- how processes are supervised
-- which users, tokens, or routes exist in the host product
+Manager methods:
 
-## Main Planning API
+- `start(options)`
+- `stop(options)`
+- `restart(options)`
+- `getStatus(options)`
+- `readDiagnostics(options)`
 
-### `createCodeServerLaunchPlan(options)`
+### `startCodeServerSession(options)`
 
-This is the main higher-level API. It returns a structured `CodeServerLaunchPlan` with:
+One-shot helper that creates a manager and starts a session.
 
-- `command`
-- `args`
-- `cwd`
-- `env`
-- `entryKind`
-- `launchMode`
-- `installation`
-- `userDataDir`
-- `extensionsDir`
-- `supportRoot`
-- `supportBindings`
-- `recommendedReadablePaths`
-- `recommendedWritablePaths`
+Lifecycle-managed session APIs require:
+
+- `sessionKey`
+- `stateRoot`
+
+Defaults:
+
+- `launchStrategy` defaults to `"direct"`
+- reuse defaults to exact normalized spec match
+- `dataRoot` defaults to `stateRoot/sessions/<sessionKey>/runtime`
+- systemd never defaults its scope
+
+### `stopCodeServerSession(options)`
+
+Stops a direct child process or a systemd transient unit using the stored session metadata. If profile persistence is configured, the package persists allowlisted profile items after stop.
+
+### `restartCodeServerSession(options)`
+
+Runs stop then start with the same session request shape.
+
+### `getCodeServerSessionStatus(options)`
+
+Loads the package-owned session record and re-probes the live backing resource instead of trusting disk alone.
+
+### `readCodeServerSessionDiagnostics(options)`
+
+Reads the persisted diagnostics snapshot for a session.
+
+## Session Metadata
+
+The package stores generic lifecycle metadata under:
+
+- `<stateRoot>/sessions/<safe-session-key>/session.json`
+- `<stateRoot>/sessions/<safe-session-key>/diagnostics.json`
+
+The session record tracks values such as:
+
+- `state`
+- `launchStrategy`
+- `specHash`
 - `bindAddr`
-- `host`
 - `port`
-- `trustedOrigins`
+- `userDataDir`
+- `extensionsDir`
 - `workspacePath`
+- `pid` for direct launches
+- `unitName` and `systemdScope` for systemd launches
+- timestamps and normalized failure details
 
-If you pass `dataRoot`, the package derives:
+This disk-backed record is what allows the package to reuse, stop, restart, and inspect sessions across calls.
 
-- `${dataRoot}/user-data`
-- `${dataRoot}/extensions`
+## Reuse Model
 
-If you omit `port` or pass `0`, the package allocates a free TCP port first.
+The package builds a normalized session spec from the effective launch plan plus lifecycle-relevant inputs such as:
 
-Example:
+- launch strategy
+- workspace path
+- trusted origins
+- env overrides
+- profile restore and persist configuration
+- systemd scope and unit naming
 
-```ts
-import { createCodeServerLaunchPlan } from "@trebired/code-server-kit";
+That normalized spec is hashed and stored. Reuse only happens when:
 
-const plan = await createCodeServerLaunchPlan({
-  dataRoot: "/srv/code-server/session-42",
-  host: "127.0.0.1",
-  port: 0,
-  trustedOrigins: [
-    "https://app.example.com",
-    "https://admin.example.com",
-  ],
-  workspacePath: "/srv/workspaces/demo",
-});
-```
+- the same `sessionKey` is used
+- the spec hash matches exactly
+- the backing process or unit still exists
+- the target port becomes ready again
+
+If the hash changes, the package marks the old record stale, stops the old runtime when needed, and starts a fresh session.
+
+## Launch Planning APIs
+
+The lower-level launch planning APIs remain available for callers that want policy ownership while still avoiding `code-server` package-layout details.
 
 ### `resolveCodeServerInstallation(options?)`
 
-Use this lower-level helper when you only need installation metadata:
+Returns installation metadata:
 
 - `packageRoot`
 - `packageJsonPath`
@@ -132,55 +187,51 @@ Use this lower-level helper when you only need installation metadata:
 - `supportRoot`
 - `version`
 
-### `createCodeServerLaunch(options)`
+### `createCodeServerLaunchPlan(options)`
 
-This remains available as a compatibility-friendly alias for `createCodeServerLaunchPlan()`.
+Returns a structured launch plan with:
 
-## Launch Specs And Sandbox Helpers
+- `command`
+- `args`
+- `cwd`
+- `env`
+- `entryKind`
+- `launchMode`
+- `installation`
+- `bindAddr`
+- `host`
+- `port`
+- `supportRoot`
+- `supportBindings`
+- `recommendedReadablePaths`
+- `recommendedWritablePaths`
+- `userDataDir`
+- `extensionsDir`
+- `workspacePath`
 
 ### `createCodeServerLaunchSpec(plan)`
 
-Converts a launch plan into a smaller execution-oriented shape:
+Converts the launch plan into an execution-oriented shape:
 
 - `command`
 - `args`
 - `cwd`
 - `env`
+- `bindings`
 - `readablePaths`
 - `writablePaths`
-- `bindings`
-
-This is useful when a caller wants to feed the launch plan into:
-
-- a direct child-process launch
-- a systemd unit generator
-- a container wrapper
-- a custom sandbox layer
 
-### `formatCodeServerCommand(planOrSpec)`
+This is useful when a host wants to feed the same plan into a container, custom sandbox, or generated unit file.
 
-Formats the command and arg vector as one safely escaped string for logs, debug output, shell transcripts, or generated unit files.
+## Direct Launch
 
-### `normalizeCodeServerStartupFailure(error)`
-
-Converts package-specific and generic thrown values into one consistent startup-failure shape with:
-
-- `name`
-- `message`
-- `code`
-- `details`
-- `isCodeServerKitError`
-
-## Launching Strategies
-
-### Direct Child Process
-
-Use the built-in launcher when you want a plain host-owned child process:
+Use the built-in child-process helper when you want a plain process owned by the current Node.js runtime.
 
 ```ts
 import {
   createCodeServerLaunchPlan,
   launchCodeServerProcess,
+  waitForCodeServerReady,
 } from "@trebired/code-server-kit";
 
 const plan = await createCodeServerLaunchPlan({
@@ -189,66 +240,52 @@ const plan = await createCodeServerLaunchPlan({
 });
 
 const handle = await launchCodeServerProcess({ plan });
-```
 
-### Systemd
+await waitForCodeServerReady({
+  host: plan.host,
+  port: plan.port,
+  process: handle,
+});
+```
 
-Use `createCodeServerLaunchPlan()` or `createCodeServerLaunchSpec()` to generate:
+The lifecycle manager uses this same lower-level path internally for `launchStrategy: "direct"`.
 
-- `ExecStart` from `command` plus `args`
-- `WorkingDirectory` from `cwd`
-- `Environment` lines from `env`
-- read and write path policy from `bindings`, `readablePaths`, and `writablePaths`
+## Systemd Launch
 
-### Containers
+Linux systemd support is built into the same package and stays explicit.
 
-Use the launch plan to decide:
+Use `launchStrategy: "systemd"` only when you also provide:
 
-- which package and support paths should be mounted read-only
-- which runtime paths should be mounted writable
-- the final command and arg vector inside the container
+- `systemd.scope: "user"` or `"system"`
 
-The package does not impose a container layout. It only returns generic path suggestions.
+The package uses transient services through `systemd-run`, not scopes.
 
-### Custom Sandboxes
+Relevant APIs:
 
-Use `supportBindings`, `recommendedReadablePaths`, and `recommendedWritablePaths` as generic inputs to your own sandbox policy. Host apps can tighten or expand those lists without re-deriving them from package internals.
+- `launchCodeServerWithSystemd(options)`
+- `stopCodeServerSystemdUnit(options)`
+- `readCodeServerSystemdStatus(options)`
+- `readCodeServerSystemdJournal(options)`
+- `createCodeServerSystemdLaunchCommand(options)`
+- `buildSystemdPathProperties(spec)`
 
-## Readiness Helpers
+The systemd translation layer derives:
 
-### `waitForCodeServerReady(options)`
+- `--unit`
+- `--working-directory`
+- `--setenv`
+- `BindPaths`
+- `BindReadOnlyPaths`
+- `ReadOnlyPaths`
+- `ReadWritePaths`
 
-Waits for the target TCP port to accept connections and can also:
+That means host applications do not need to rebuild transient unit arguments from raw launch-plan data themselves.
 
-- fail on startup timeout
-- fail early if a child process exits first
-- run a caller-provided `failureProbe`
+## Profile Restore And Persist
 
-The readiness helper throws structured errors instead of returning vague booleans.
+Profile sync stays allowlist-based rather than copying the entire runtime tree.
 
-Example:
-
-```ts
-await waitForCodeServerReady({
-  host: plan.host,
-  port: plan.port,
-  process: handle,
-  failureProbe({ elapsedMs }) {
-    if (elapsedMs > 10_000) {
-      return {
-        message: "startup looked stalled",
-      };
-    }
-    return null;
-  },
-});
-```
-
-## Profile Sync Helpers
-
-The package now includes generic profile sync helpers built around an allowlist model.
-
-Supported profile items:
+Supported items:
 
 - `settings.json`
 - `extensions.json`
@@ -256,89 +293,103 @@ Supported profile items:
 - `snippets`
 - `extensions`
 
-### `createCodeServerProfileSyncPlan(options)`
+Lower-level helpers:
 
-Builds a sync plan between two profile roots without copying anything yet.
+- `createCodeServerProfileSyncPlan(options)`
+- `syncCodeServerProfile(options)`
+- `resolveCodeServerProfilePathMap(overrides?)`
 
-### `syncCodeServerProfile(options)`
+Lifecycle integration:
 
-Copies only the allowlisted profile items. By default it skips missing or unreadable sources cleanly instead of assuming full access to every runtime-owned path.
+- restore before launch with `profile.restoreFrom`
+- persist after stop with `profile.persistTo`
+- skip missing or unreadable sources cleanly by default
 
 Example:
 
 ```ts
-import { syncCodeServerProfile } from "@trebired/code-server-kit";
-
-const result = await syncCodeServerProfile({
-  sourceDir: "/srv/persisted-profile",
-  targetDir: "/srv/runtime-profile",
-  items: ["settings.json", "snippets", "extensions"],
+await sessions.start({
+  profile: {
+    items: ["settings.json", "keybindings.json", "extensions"],
+    persistTo: "/srv/profiles/demo",
+    restoreFrom: "/srv/profiles/demo",
+  },
+  sessionKey: "workspace-42",
+  stateRoot: "/srv/code-server-state",
+  workspacePath: "/srv/workspaces/demo",
 });
-
-console.log(result.copied.length, result.skipped.length);
 ```
 
-Default relative paths are also exported through `DEFAULT_CODE_SERVER_PROFILE_PATHS`, and callers can override them when needed through `pathMap`.
-
-## Reverse Proxy Helpers
-
-### `normalizeTrustedOrigins(origins)`
-
-Normalizes absolute origins for launch planning and rejects invalid values clearly.
+## Readiness And Failure Handling
 
-### `normalizeTrustedOrigin(origin)`
-
-Normalizes one origin value.
-
-### `buildForwardedHeaders(options)`
+### `waitForCodeServerReady(options)`
 
-Builds a small forwarded-header record for reverse-proxy embedding.
+Waits for the TCP port to accept connections and can also:
 
-### `isCodeServerHtmlResponse(options)`
+- fail on startup timeout
+- fail on direct-process early exit
+- fail on a caller-provided failure probe
 
-Returns `true` when a response looks like HTML that a host app may want to transform before returning it to a browser.
+The lifecycle manager builds on this and adds strategy-aware supervision:
 
-This helper is intentionally narrow. It does not rewrite routes or inject product-specific markup.
+- direct-process stdout and stderr tails
+- systemd state probing
+- systemd journal collection
+- normalized startup failure metadata
 
 ## Structured Errors
 
-The package exposes structured error classes so host apps can log clearly and branch reliably:
+The package throws structured error classes so callers can log and branch on them reliably.
+
+Examples:
 
+- `CodeServerInvalidConfigurationError`
 - `CodeServerInstallationResolutionError`
 - `CodeServerEntrypointResolutionError`
 - `CodeServerLaunchPlanningError`
-- `CodeServerInvalidConfigurationError`
 - `CodeServerPortAllocationError`
-- `CodeServerProcessExitedBeforeReadyError`
-- `CodeServerStartupProbeError`
 - `CodeServerStartupTimeoutError`
+- `CodeServerProcessExitedBeforeReadyError`
+- `CodeServerSessionLifecycleError`
+- `CodeServerSessionReuseConflictError`
+- `CodeServerSystemdLaunchError`
+- `CodeServerSystemdCollisionError`
+- `CodeServerSystemdStatusError`
+- `CodeServerSystemdJournalError`
+
+Use `normalizeCodeServerStartupFailure(error)` when you want one tagged object shape for logs or API responses.
+
+## Reverse Proxy Helpers
+
+The package also includes a few small generic embedding helpers:
+
+- `buildForwardedHeaders(options)`
+- `normalizeTrustedOrigin(value)`
+- `isCodeServerHtmlResponse(options)`
+
+These helpers stay intentionally small. They do not add product-specific route rewriting.
+
+## Logging
+
+High-level APIs accept:
 
-The earlier compatibility exports are still available:
+- `logger`
+- `loggerAdapter`
 
-- `CodeServerPackageResolutionError`
-- `CodeServerBinaryNotFoundError`
+The package resolves those through `@trebired/logger-adapter`, matching the style used by other `@trebired/*` packages. `createCodeServerSessionManager()` also emits `logPackageInitialized()` on creation.
 
-## Public Surface
+## `code-server`: Dependency vs Peer Dependency
 
-The current API is centered around these exports:
+Use `code-server` as a normal `dependency` when:
 
-- `resolveCodeServerInstallation()`
-- `createCodeServerLaunchPlan()`
-- `createCodeServerLaunch()`
-- `createCodeServerLaunchSpec()`
-- `launchCodeServerProcess()`
-- `waitForCodeServerReady()`
-- `createCodeServerProfileSyncPlan()`
-- `syncCodeServerProfile()`
-- `buildForwardedHeaders()`
-- `normalizeTrustedOrigins()`
-- `normalizeTrustedOrigin()`
-- `isCodeServerHtmlResponse()`
-- `formatCodeServerCommand()`
-- `normalizeCodeServerStartupFailure()`
+- this package is part of an application deployment
+- you want the runtime to own the exact installed `code-server`
+- you want installation resolution to succeed without extra host setup
 
-## Dependency vs Peer Dependency for `code-server`
+Use `code-server` as a `peerDependency` in your own higher-level package when:
 
-For an application, prefer a regular `dependency` on `code-server` when you want one installed runtime and want `@trebired/code-server-kit` to resolve the same package reliably every time.
+- your package wraps `@trebired/code-server-kit`
+- the final host application should choose the `code-server` version
+- you want to avoid forcing duplicate `code-server` installs across wrappers
 
-For a wrapper library on top of this package, prefer a `peerDependency` on `code-server` when the host application must choose the exact `code-server` version and install location itself. In that setup, document that `code-server` must still be resolvable from the host application's dependency tree, and pass `resolveFrom` when you need to anchor resolution to the host side explicitly.
+`@trebired/code-server-kit` itself depends on `code-server` because the generic runtime layer needs a predictable package to resolve.

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-type CodeServerKitErrorCode = "entrypoint_resolution_failed" | "installation_resolution_failed" | "invalid_configuration" | "launch_planning_failed" | "port_allocation_failed" | "process_exited_before_ready" | "startup_probe_failed" | "startup_timeout";
+type CodeServerKitErrorCode = "entrypoint_resolution_failed" | "installation_resolution_failed" | "invalid_configuration" | "launch_planning_failed" | "port_allocation_failed" | "process_exited_before_ready" | "session_lifecycle_failed" | "session_reuse_conflict" | "startup_probe_failed" | "startup_timeout" | "systemd_collision" | "systemd_journal_failed" | "systemd_launch_failed" | "systemd_status_failed";
 declare class CodeServerKitError extends Error {
     code: CodeServerKitErrorCode | string;
     details: Record<string, unknown>;
@@ -28,6 +28,24 @@ declare class CodeServerStartupTimeoutError extends CodeServerKitError {
 declare class CodeServerStartupProbeError extends CodeServerKitError {
     constructor(message: string, details?: Record<string, unknown>);
 }
+declare class CodeServerSessionLifecycleError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSessionReuseConflictError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdLaunchError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdCollisionError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdStatusError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class CodeServerSystemdJournalError extends CodeServerKitError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
 declare class CodeServerPackageResolutionError extends CodeServerInstallationResolutionError {
     constructor(message: string, details?: Record<string, unknown>);
 }
@@ -35,6 +53,6 @@ declare class CodeServerBinaryNotFoundError extends CodeServerEntrypointResoluti
     constructor(message: string, details?: Record<string, unknown>);
 }
 declare function isCodeServerKitError(value: unknown): value is CodeServerKitError;
-export { CodeServerBinaryNotFoundError, CodeServerEntrypointResolutionError, CodeServerInstallationResolutionError, CodeServerInvalidConfigurationError, CodeServerKitError, CodeServerLaunchPlanningError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerStartupProbeError, CodeServerStartupTimeoutError, isCodeServerKitError, };
+export { CodeServerBinaryNotFoundError, CodeServerEntrypointResolutionError, CodeServerInstallationResolutionError, CodeServerInvalidConfigurationError, CodeServerKitError, CodeServerLaunchPlanningError, CodeServerPackageResolutionError, CodeServerPortAllocationError, CodeServerProcessExitedBeforeReadyError, CodeServerSessionLifecycleError, CodeServerSessionReuseConflictError, CodeServerStartupProbeError, CodeServerStartupTimeoutError, CodeServerSystemdCollisionError, CodeServerSystemdJournalError, CodeServerSystemdLaunchError, CodeServerSystemdStatusError, isCodeServerKitError, };
 export type { CodeServerKitErrorCode };
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,KAAK,sBAAsB,GACvB,8BAA8B,GAC9B,gCAAgC,GAChC,uBAAuB,GACvB,wBAAwB,GACxB,wBAAwB,GACxB,6BAA6B,GAC7B,sBAAsB,GACtB,iBAAiB,CAAC;AAEtB,cAAM,kBAAmB,SAAQ,KAAK;IACpC,IAAI,EAAE,sBAAsB,GAAG,MAAM,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAErB,IAAI,EAAE,sBAAsB,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAM1G;AAED,cAAM,qCAAsC,SAAQ,kBAAkB;gBACxD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,mCAAoC,SAAQ,kBAAkB;gBACtD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,mCAAoC,SAAQ,kBAAkB;gBACtD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,uCAAwC,SAAQ,kBAAkB;gBAC1D,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,kBAAkB;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,2BAA4B,SAAQ,kBAAkB;gBAC9C,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,gCAAiC,SAAQ,qCAAqC;gBACtE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,cAAM,6BAA8B,SAAQ,mCAAmC;gBACjE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;CAInE;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAEzE;AAED,OAAO,EACL,6BAA6B,EAC7B,mCAAmC,EACnC,qCAAqC,EACrC,mCAAmC,EACnC,kBAAkB,EAClB,6BAA6B,EAC7B,gCAAgC,EAChC,6BAA6B,EAC7B,uCAAuC,EACvC,2BAA2B,EAC3B,6BAA6B,EAC7B,oBAAoB,GACrB,CAAC;AACF,YAAY,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}