@mx-space/cli 0.2.3 → 0.3.0

package/dist/index.d.mts

@@ -1,396 +1,1514 @@
-import { a as emitSuccess, i as emitInfo, n as defaultOutputOptions, o as emitWarn, r as emitError, s as renderTable, t as OutputOptions } from "./output-D2dDlyV2.mjs";
+import { t as run } from "./mxs-CM8-6uAr.mjs";
 
-//#region src/core/config-dir.d.ts
-declare function getConfigDir(): string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Types.d.ts
+/**
+ * Invariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+type Invariant<A> = (_: A) => A;
+/**
+ * @since 3.9.0
+ * @category models
+ */
+declare namespace Invariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  type Type<A> = A extends Invariant<infer U> ? U : never;
+}
+/**
+ * Covariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+type Covariant<A> = (_: never) => A;
+/**
+ * @since 3.9.0
+ * @category models
+ */
+declare namespace Covariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  type Type<A> = A extends Covariant<infer U> ? U : never;
+}
+/**
+ * Contravariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+type Contravariant<A> = (_: A) => void;
+/**
+ * @since 3.9.0
+ * @category models
+ */
+declare namespace Contravariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  type Type<A> = A extends Contravariant<infer U> ? U : never;
+}
+/**
+ * Conditional type that returns `void` if `S` is an empty object type,
+ * otherwise returns `S`.
+ *
+ * @since 3.19.20
+ */
+type VoidIfEmpty<S> = keyof S extends never ? void : S;
+//#endregion
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Hash.d.ts
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface Hash {
+  [symbol](): number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Equal.d.ts
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface Equal extends Hash {
+  [symbol](that: Equal): boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Pipeable.d.ts
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+interface Pipeable {
+  pipe<A>(this: A): A;
+  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
+  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
+  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
+  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
+  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Unify.d.ts
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ */
+declare const unifySymbol: unique symbol;
+/**
+ * @since 2.0.0
+ */
+type unifySymbol = typeof unifySymbol;
+/**
+ * @since 2.0.0
+ */
+declare const typeSymbol: unique symbol;
+/**
+ * @since 2.0.0
+ */
+type typeSymbol = typeof typeSymbol;
+/**
+ * @since 2.0.0
+ */
+declare const ignoreSymbol: unique symbol;
+/**
+ * @since 2.0.0
+ */
+type ignoreSymbol = typeof ignoreSymbol;
 //#endregion
-//#region src/core/config-store.d.ts
-interface ConfigShape {
-  api_url?: string;
-  api_base?: string;
-  auth_base?: string;
-  api_version?: number;
-  client_id?: string;
-  production?: boolean;
-}
-interface CredentialsShape {
-  access_token: string;
-  refresh_token?: string;
-  expires_at: number;
-  user?: {
-    id?: string;
-    email?: string;
-    name?: string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Utils.d.ts
+/**
+ * @since 3.0.6
+ */
+declare const YieldWrapTypeId: unique symbol;
+/**
+ * @since 3.0.6
+ */
+declare class YieldWrap<T> {
+  #private;
+  constructor(value: T);
+  /**
+   * @since 3.0.6
+   */
+  [YieldWrapTypeId](): T;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Option.d.ts
+/**
+ * The `Option` data type represents optional values. An `Option<A>` can either
+ * be `Some<A>`, containing a value of type `A`, or `None`, representing the
+ * absence of a value.
+ *
+ * **When to Use**
+ *
+ * You can use `Option` in scenarios like:
+ *
+ * - Using it for initial values
+ * - Returning values from functions that are not defined for all possible
+ *   inputs (referred to as “partial functions”)
+ * - Managing optional fields in data structures
+ * - Handling optional function arguments
+ *
+ * @category Models
+ * @since 2.0.0
+ */
+type Option<A> = None$1<A> | Some$1<A>;
+/**
+ * @category Symbols
+ * @since 2.0.0
+ */
+declare const TypeId$2: unique symbol;
+/**
+ * @category Symbols
+ * @since 2.0.0
+ */
+type TypeId$2 = typeof TypeId$2;
+/**
+ * @category Models
+ * @since 2.0.0
+ */
+interface None$1<out A> extends Pipeable, Inspectable {
+  readonly _tag: "None";
+  readonly _op: "None";
+  readonly [TypeId$2]: {
+    readonly _A: Covariant<A>;
+  };
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: OptionUnify<this>;
+  [ignoreSymbol]?: OptionUnifyIgnore;
+}
+/**
+ * @category Models
+ * @since 2.0.0
+ */
+interface Some$1<out A> extends Pipeable, Inspectable {
+  readonly _tag: "Some";
+  readonly _op: "Some";
+  readonly value: A;
+  readonly [TypeId$2]: {
+    readonly _A: Covariant<A>;
   };
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: OptionUnify<this>;
+  [ignoreSymbol]?: OptionUnifyIgnore;
 }
-interface ResolvedConfig {
-  apiUrl: string;
-  apiBase: string;
-  authBase: string;
-  apiVersion: number;
-  clientId: string;
-  token?: string;
-  apiKey?: string;
-  configPath: string;
-  credentialsPath: string;
-  profileName: string | null;
-  isProduction: boolean;
-  profileExplicit: boolean;
-  urlOverridden: boolean;
-}
-interface StoreOverrides {
-  apiUrl?: string;
-  token?: string;
-  apiKey?: string;
-  profile?: string;
-}
-/** @deprecated Use getLegacyConfigPath for migration logic only */
-declare function getConfigPath(): string;
-/** @deprecated Use getLegacyCredentialsPath for migration logic only */
-declare function getCredentialsPath(): string;
-declare function readConfig(): Promise<ConfigShape>;
-declare function writeConfig(cfg: ConfigShape): Promise<void>;
-/**
- * @deprecated Read from profile credentials via `readProfileCredentials` in core/profile.ts.
- * Kept for the legacy migration read path and api-client auto-refresh; remove after full profile migration.
- */
-declare function readCredentials(): Promise<CredentialsShape | null>;
-/**
- * @deprecated Write to profile credentials via `writeProfileCredentials` in core/profile.ts.
- * Kept for the legacy migration read path and api-client auto-refresh; remove after full profile migration.
- */
-declare function writeCredentials(cred: CredentialsShape): Promise<void>;
-/**
- * @deprecated Use `deleteProfileCredentials` in core/profile.ts for profile-aware logout.
- * Kept only for Task 2 migration's read path; remove after full profile migration.
- */
-declare function deleteCredentials(): Promise<void>;
-declare function enforceCredentialsMode(p?: string): Promise<boolean>;
-declare function normalizeApiUrl(input: string): string;
-declare function resolveConfig(overrides?: StoreOverrides): Promise<ResolvedConfig>;
+/**
+ * @category Models
+ * @since 2.0.0
+ */
+interface OptionUnify<A extends {
+  [typeSymbol]?: any;
+}> {
+  Option?: () => A[typeSymbol] extends Option<infer A0> | infer _ ? Option<A0> : never;
+}
+/**
+ * @since 2.0.0
+ */
+declare namespace Option {
+  /**
+   * Extracts the type of the value contained in an `Option`.
+   *
+   * **Example** (Getting the Value Type of an Option)
+   *
+   * ```ts
+   * import { Option } from "effect"
+   *
+   * // Declare an Option holding a string
+   * declare const myOption: Option.Option<string>
+   *
+   * // Extract the type of the value within the Option
+   * //
+   * //      ┌─── string
+   * //      ▼
+   * type MyType = Option.Option.Value<typeof myOption>
+   * ```
+   *
+   * @since 2.0.0
+   * @category Type-level Utils
+   */
+  type Value<T extends Option<any>> = [T] extends [Option<infer _A>] ? _A : never;
+}
+/**
+ * @category Models
+ * @since 2.0.0
+ */
+interface OptionUnifyIgnore {}
 //#endregion
-//#region src/core/auth.d.ts
-declare const SUPPORTED_API_VERSIONS: readonly [2];
-interface DeviceCodeResponse {
-  device_code: string;
-  user_code: string;
-  verification_uri: string;
-  verification_uri_complete?: string;
-  expires_in: number;
-  interval: number;
-}
-interface DeviceTokenResponse {
-  access_token: string;
-  token_type: string;
-  expires_in: number;
-  refresh_token?: string;
-  scope?: string;
-  user?: {
-    id?: string;
-    email?: string;
-    name?: string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Context.d.ts
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+declare const TagTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+type TagTypeId = typeof TagTypeId;
+/**
+ * @since 3.5.9
+ * @category models
+ */
+interface Tag$2<in out Id, in out Value> extends Pipeable, Inspectable, ReadonlyTag<Id, Value> {
+  readonly _op: "Tag";
+  readonly Service: Value;
+  readonly Identifier: Id;
+  readonly [TagTypeId]: {
+    readonly _Service: Invariant<Value>;
+    readonly _Identifier: Invariant<Id>;
+  };
+  of(self: Value): Value;
+  context(self: Value): Context$1<Id>;
+  readonly stack?: string | undefined;
+  readonly key: string;
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: TagUnify<this>;
+  [ignoreSymbol]?: TagUnifyIgnore;
+}
+/**
+ * @since 3.5.9
+ * @category models
+ */
+interface ReadonlyTag<in out Id, out Value> extends Pipeable, Inspectable, Effect<Value, never, Id> {
+  readonly _op: "Tag";
+  readonly Service: Value;
+  readonly Identifier: Id;
+  readonly [TagTypeId]: {
+    readonly _Service: Covariant<Value>;
+    readonly _Identifier: Invariant<Id>;
   };
+  readonly stack?: string | undefined;
+  readonly key: string;
 }
-interface ProbeResult {
-  apiUrl: string;
-  apiBase: string;
-  authBase: string;
-  apiVersion: number;
-}
-interface AuthHttp {
-  fetch: typeof fetch;
-}
-declare function probeAuthEndpoint(apiUrl: string, http?: AuthHttp): Promise<ProbeResult>;
-declare function requestDeviceCode(authBase: string, clientId: string, scope?: string, http?: AuthHttp): Promise<DeviceCodeResponse>;
-interface PollOptions {
-  intervalSec: number;
-  expiresInSec: number;
-  signal?: AbortSignal;
-  onTick?: (state: 'pending' | 'slow_down') => void;
-  http?: AuthHttp;
-}
-declare function pollDeviceToken(authBase: string, clientId: string, deviceCode: string, opts: PollOptions): Promise<DeviceTokenResponse>;
-declare function toCredentials(resp: DeviceTokenResponse): CredentialsShape;
-declare function isExpiringSoon(cred: CredentialsShape, bufferMs?: number): boolean;
-declare function refreshAccessToken(authBase: string, clientId: string, cred: CredentialsShape, http?: AuthHttp): Promise<CredentialsShape | null>;
-declare function loadCredentialsOrThrow(): Promise<CredentialsShape>;
-declare function ensureFreshToken(authBase: string, clientId: string, http?: AuthHttp): Promise<CredentialsShape>;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface TagClassShape<Id, Shape> {
+  readonly [TagTypeId]: TagTypeId;
+  readonly Type: Shape;
+  readonly Id: Id;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface TagClass<Self, Id extends string, Type> extends Tag$2<Self, Type> {
+  new (_: never): TagClassShape<Id, Type>;
+  readonly key: Id;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface TagUnify<A extends {
+  [typeSymbol]?: any;
+}> {
+  Tag?: () => Extract<A[typeSymbol], Tag$2<any, any>>;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface TagUnifyIgnore {}
+/**
+ * @since 2.0.0
+ */
+declare namespace Tag$2 {
+  /**
+   * @since 2.0.0
+   */
+  type Service<T extends Tag$2<any, any> | TagClassShape<any, any>> = T extends Tag$2<any, any> ? T["Service"] : T extends TagClassShape<any, infer A> ? A : never;
+  /**
+   * @since 2.0.0
+   */
+  type Identifier<T extends Tag$2<any, any> | TagClassShape<any, any>> = T extends Tag$2<any, any> ? T["Identifier"] : T extends TagClassShape<any, any> ? T : never;
+}
+declare const TypeId$1: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+type TypeId$1 = typeof TypeId$1;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface Context$1<in Services> extends Equal, Pipeable, Inspectable {
+  readonly [TypeId$1]: {
+    readonly _Services: Contravariant<Services>;
+  };
+  readonly unsafeMap: Map<string, any>;
+}
+/**
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Context, Layer } from "effect"
+ *
+ * class MyTag extends Context.Tag("MyTag")<
+ *  MyTag,
+ *  { readonly myNum: number }
+ * >() {
+ *  static Live = Layer.succeed(this, { myNum: 108 })
+ * }
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+declare const Tag$2: <const Id extends string>(id: Id) => <Self, Shape>() => TagClass<Self, Id, Shape>;
 //#endregion
-//#region src/core/api-client.d.ts
-interface ApiClientContext {
-  apiBase: string;
-  authBase: string;
-  clientId: string;
-  token?: string;
-  apiKey?: string;
-  autoRefresh?: boolean;
-  verbose?: boolean;
-  quiet?: boolean;
-  http?: AuthHttp;
-  /** When provided, enables the production banner and write gate. */
-  resolved?: ResolvedConfig;
-}
-interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
-  body?: unknown;
-  query?: Record<string, unknown>;
-  headers?: Record<string, string>;
-  signal?: AbortSignal;
-}
-interface ApiResponse<T> {
-  ok: boolean;
-  status: number;
-  data: T;
-}
-declare class ApiClient {
-  private ctx;
-  private http;
-  private token?;
-  private refreshed;
-  constructor(ctx: ApiClientContext);
-  get apiBase(): string;
-  request<T = unknown>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
-  private tryRefresh;
-}
-declare function createApiClient(ctx: ApiClientContext): Promise<ApiClient>;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Sink.d.ts
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+declare const SinkTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+type SinkTypeId = typeof SinkTypeId;
+/**
+ * A `Sink<A, In, L, E, R>` is used to consume elements produced by a `Stream`.
+ * You can think of a sink as a function that will consume a variable amount of
+ * `In` elements (could be 0, 1, or many), might fail with an error of type `E`,
+ * and will eventually yield a value of type `A` together with a remainder of
+ * type `L` (i.e. any leftovers).
+ *
+ * @since 2.0.0
+ * @category models
+ */
+interface Sink<out A, in In = unknown, out L = never, out E = never, out R = never> extends Sink.Variance<A, In, L, E, R>, Pipeable {}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Effect.js" {
+  interface Effect<A, E, R> extends Sink<A, unknown, never, E, R> {}
+  interface EffectUnifyIgnore {
+    Sink?: true;
+  }
+}
+/**
+ * @since 2.0.0
+ */
+declare namespace Sink {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface Variance<out A, in In, out L, out E, out R> {
+    readonly [SinkTypeId]: VarianceStruct<A, In, L, E, R>;
+  }
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface VarianceStruct<out A, in In, out L, out E, out R> {
+    _A: Covariant<A>;
+    _In: Contravariant<In>;
+    _L: Covariant<L>;
+    _E: Covariant<E>;
+    _R: Covariant<R>;
+  }
+}
 //#endregion
-//#region src/core/content-spec.d.ts
-interface ContentSource {
-  text: string;
-  origin: 'inline' | 'file' | 'stdin';
-  path?: string;
-}
-declare function readContentSpec(spec: string | undefined, {
-  cwd
-}?: {
-  cwd?: string;
-}): Promise<ContentSource | null>;
-declare function readJsonSpec(spec: string | undefined): Promise<unknown>;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/STM.d.ts
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+declare const STMTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+type STMTypeId = typeof STMTypeId;
+/**
+ * `STM<A, E, R>` represents an effect that can be performed transactionally,
+ *  resulting in a failure `E` or a value `A` that may require an environment
+ *  `R` to execute.
+ *
+ * Software Transactional Memory is a technique which allows composition of
+ * arbitrary atomic operations.  It is the software analog of transactions in
+ * database systems.
+ *
+ * The API is lifted directly from the Haskell package Control.Concurrent.STM
+ * although the implementation does not resemble the Haskell one at all.
+ *
+ * See http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html
+ *
+ * STM in Haskell was introduced in:
+ *
+ * Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton
+ * Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of
+ * Parallel Programming 2005.
+ *
+ * See https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/
+ *
+ * See also:
+ *  Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim
+ *  Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth
+ *  International Symposium on Functional and Logic Programming, Fuji Susono,
+ *  JAPAN, April 2006
+ *
+ *  https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/
+ *
+ * The implemtation is based on the ZIO STM module, while JS environments have
+ * no race conditions from multiple threads STM provides greater benefits for
+ * synchronization of Fibers and transactional data-types can be quite useful.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+interface STM<out A, out E = never, out R = never> extends Effect<A, E, R>, STM.Variance<A, E, R>, Pipeable {
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: STMUnify<this>;
+  [ignoreSymbol]?: STMUnifyIgnore;
+  [Symbol.iterator](): EffectGenerator<STM<A, E, R>>;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface STMUnify<A extends {
+  [typeSymbol]?: any;
+}> extends EffectUnify<A> {
+  STM?: () => A[typeSymbol] extends STM<infer A0, infer E0, infer R0> | infer _ ? STM<A0, E0, R0> : never;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface STMUnifyIgnore extends EffectUnifyIgnore {
+  Effect?: true;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Context.js" {
+  interface Tag<Id, Value> extends STM<Value, never, Id> {}
+  interface Reference<Id, Value> extends STM<Value> {}
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Either.js" {
+  interface Left<E, A> extends STM<A, E> {
+    readonly _tag: "Left";
+  }
+  interface Right<E, A> extends STM<A, E> {
+    readonly _tag: "Right";
+  }
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Option.js" {
+  interface None<A> extends STM<A, NoSuchElementException> {
+    readonly _tag: "None";
+  }
+  interface Some<A> extends STM<A, NoSuchElementException> {
+    readonly _tag: "Some";
+  }
+}
+/**
+ * @since 2.0.0
+ */
+declare namespace STM {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface Variance<out A, out E, out R> {
+    readonly [STMTypeId]: {
+      readonly _A: Covariant<A>;
+      readonly _E: Covariant<E>;
+      readonly _R: Covariant<R>;
+    };
+  }
+}
 //#endregion
-//#region src/core/document-output.d.ts
-type DocumentKind = 'post' | 'note' | 'page';
-declare function emitDocument(kind: DocumentKind, data: unknown, opts: OutputOptions): void;
-declare function emitPostList(data: unknown, opts: OutputOptions): void;
-declare function renderReadableDocument(kind: DocumentKind, data: unknown): string;
-declare function renderPostList(data: unknown): string;
-declare function renderDocumentEnvelope(kind: DocumentKind, data: unknown): string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Stream.d.ts
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+declare const StreamTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+type StreamTypeId = typeof StreamTypeId;
+/**
+ * A `Stream<A, E, R>` is a description of a program that, when evaluated, may
+ * emit zero or more values of type `A`, may fail with errors of type `E`, and
+ * uses an context of type `R`. One way to think of `Stream` is as a
+ * `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage
+ * buffers between operators. As an optimization, `Stream` does not emit
+ * single values, but rather an array of values. This allows the cost of effect
+ * evaluation to be amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with
+ * some adjustments for the multiple-valued nature of `Stream`). These aspects
+ * allow for rich and expressive composition of streams.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+interface Stream<out A, out E = never, out R = never> extends Stream.Variance<A, E, R>, Pipeable {
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: StreamUnify<this>;
+  [ignoreSymbol]?: StreamUnifyIgnore;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface StreamUnify<A extends {
+  [typeSymbol]?: any;
+}> extends EffectUnify<A> {
+  Stream?: () => A[typeSymbol] extends Stream<infer A0, infer E0, infer R0> | infer _ ? Stream<A0, E0, R0> : never;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface StreamUnifyIgnore extends EffectUnifyIgnore {
+  Effect?: true;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Effect.js" {
+  interface Effect<A, E, R> extends Stream<A, E, R> {}
+}
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ */
+declare namespace Stream {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface Variance<out A, out E, out R> {
+    readonly [StreamTypeId]: VarianceStruct<A, E, R>;
+  }
+  /**
+   * @since 3.4.0
+   * @category models
+   */
+  interface VarianceStruct<out A, out E, out R> {
+    readonly _A: Covariant<A>;
+    readonly _E: Covariant<E>;
+    readonly _R: Covariant<R>;
+  }
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  type Success<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _A : never;
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  type Error<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _E : never;
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  type Context<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _R : never;
+  /**
+   * @since 2.0.0
+   * @category models
+   * @deprecated use Types.TupleOf instead
+   */
+  type DynamicTuple<T, N extends number> = N extends N ? number extends N ? Array<T> : DynamicTupleOf<T, N, []> : never;
+  /**
+   * @since 2.0.0
+   * @category models
+   * @deprecated use Types.TupleOf instead
+   */
+  type DynamicTupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R : DynamicTupleOf<T, N, [T, ...R]>;
+}
 //#endregion
-//#region src/core/editor.d.ts
-interface EditorOptions {
-  filename: string;
-  initialContent: string;
-  editor?: string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Effect.d.ts
+/**
+ * @since 2.0.0
+ * @category Symbols
+ */
+declare const EffectTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category Symbols
+ */
+type EffectTypeId = typeof EffectTypeId;
+/**
+ * The `Effect` interface defines a value that describes a workflow or job,
+ * which can succeed or fail.
+ *
+ * **Details**
+ *
+ * The `Effect` interface represents a computation that can model a workflow
+ * involving various types of operations, such as synchronous, asynchronous,
+ * concurrent, and parallel interactions. It operates within a context of type
+ * `R`, and the result can either be a success with a value of type `A` or a
+ * failure with an error of type `E`. The `Effect` is designed to handle complex
+ * interactions with external resources, offering advanced features such as
+ * fiber-based concurrency, scheduling, interruption handling, and scalability.
+ * This makes it suitable for tasks that require fine-grained control over
+ * concurrency and error management.
+ *
+ * To execute an `Effect` value, you need a `Runtime`, which provides the
+ * environment necessary to run and manage the computation.
+ *
+ * @since 2.0.0
+ * @category Models
+ */
+interface Effect<out A, out E = never, out R = never> extends Effect.Variance<A, E, R>, Pipeable {
+  readonly [typeSymbol]?: unknown;
+  readonly [unifySymbol]?: EffectUnify<this>;
+  readonly [ignoreSymbol]?: EffectUnifyIgnore;
+  [Symbol.iterator](): EffectGenerator<Effect<A, E, R>>;
+}
+/**
+ * @since 3.0.0
+ * @category Models
+ */
+interface EffectGenerator<T extends Effect<any, any, any>> {
+  next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Effect.Success<T>>;
+}
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+interface EffectUnify<A extends {
+  [typeSymbol]?: any;
+}> extends EitherUnify<A>, OptionUnify<A>, TagUnify<A> {
+  Effect?: () => A[typeSymbol] extends Effect<infer A0, infer E0, infer R0> | infer _ ? Effect<A0, E0, R0> : never;
+}
+/**
+ * @category Models
+ * @since 2.0.0
+ */
+interface EffectUnifyIgnore {
+  Tag?: true;
+  Option?: true;
+  Either?: true;
+}
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+declare module "./Context.js" {
+  interface Tag<Id, Value> extends Effect<Value, never, Id> {
+    [Symbol.iterator](): EffectGenerator<Tag$1<Id, Value>>;
+  }
+  interface Reference<Id, Value> extends Effect<Value> {
+    [Symbol.iterator](): EffectGenerator<Reference<Id, Value>>;
+  }
+  interface TagUnifyIgnore {
+    Effect?: true;
+    Either?: true;
+    Option?: true;
+  }
+}
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+declare module "./Either.js" {
+  interface Left<E, A> extends Effect<A, E> {
+    readonly _tag: "Left";
+    [Symbol.iterator](): EffectGenerator<Left<E, A>>;
+  }
+  interface Right<E, A> extends Effect<A, E> {
+    readonly _tag: "Right";
+    [Symbol.iterator](): EffectGenerator<Right<E, A>>;
+  }
+  interface EitherUnifyIgnore {
+    Effect?: true;
+    Tag?: true;
+    Option?: true;
+  }
+}
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+declare module "./Option.js" {
+  interface None<A> extends Effect<A, NoSuchElementException> {
+    readonly _tag: "None";
+    [Symbol.iterator](): EffectGenerator<None<A>>;
+  }
+  interface Some<A> extends Effect<A, NoSuchElementException> {
+    readonly _tag: "Some";
+    [Symbol.iterator](): EffectGenerator<Some<A>>;
+  }
+  interface OptionUnifyIgnore {
+    Effect?: true;
+    Tag?: true;
+    Either?: true;
+  }
 }
-declare function runEditorRoundTrip(opts: EditorOptions): Promise<string>;
+/**
+ * @since 2.0.0
+ */
+declare namespace Effect {
+  /**
+   * @since 2.0.0
+   * @category Models
+   */
+  interface Variance<out A, out E, out R> {
+    readonly [EffectTypeId]: VarianceStruct<A, E, R>;
+  }
+  /**
+   * @since 2.0.0
+   * @category Models
+   */
+  interface VarianceStruct<out A, out E, out R> {
+    readonly _V: string;
+    readonly _A: Covariant<A>;
+    readonly _E: Covariant<E>;
+    readonly _R: Covariant<R>;
+  }
+  /**
+   * @since 2.0.0
+   * @category Effect Type Extractors
+   */
+  type Context<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _R : never;
+  /**
+   * @since 2.0.0
+   * @category Effect Type Extractors
+   */
+  type Error<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _E : never;
+  /**
+   * @since 2.0.0
+   * @category Effect Type Extractors
+   */
+  type Success<T extends Effect<any, any, any>> = [T] extends [Effect<infer _A, infer _E, infer _R>] ? _A : never;
+  /**
+   * @since 3.15.5
+   * @category Effect Type Extractors
+   */
+  type AsEffect<T extends Effect<any, any, any>> = Effect<T extends Effect<infer _A, infer _E, infer _R> ? _A : never, T extends Effect<infer _A, infer _E, infer _R> ? _E : never, T extends Effect<infer _A, infer _E, infer _R> ? _R : never> extends infer Q ? Q : never;
+}
+/**
+ * @since 2.0.0
+ * @category Models
+ */
+declare namespace Tag$1 {
+  /**
+   * @since 2.0.0
+   * @category Models
+   */
+  interface ProhibitedType {
+    Service?: `property "Service" is forbidden`;
+    Identifier?: `property "Identifier" is forbidden`;
+    _op?: `property "_op" is forbidden`;
+    of?: `property "of" is forbidden`;
+    context?: `property "context" is forbidden`;
+    key?: `property "key" is forbidden`;
+    stack?: `property "stack" is forbidden`;
+    name?: `property "name" is forbidden`;
+    pipe?: `property "pipe" is forbidden`;
+    use?: `property "use" is forbidden`;
+  }
+  /**
+   * @since 2.0.0
+   * @category Models
+   */
+  type AllowedType = (Record<PropertyKey, any> & ProhibitedType) | string | number | symbol;
+  /**
+   * @since 3.9.0
+   * @category Models
+   */
+  type Proxy<Self, Type> = { [k in keyof Type as Type[k] extends ((...args: infer Args extends ReadonlyArray<any>) => infer Ret) ? ((...args: Readonly<Args>) => Ret) extends Type[k] ? k : never : k]: Type[k] extends ((...args: infer Args extends ReadonlyArray<any>) => Effect<infer A, infer E, infer R>) ? (...args: Readonly<Args>) => Effect<A, E, Self | R> : Type[k] extends ((...args: infer Args extends ReadonlyArray<any>) => Promise<infer A>) ? (...args: Readonly<Args>) => Effect<A, UnknownException, Self> : Type[k] extends ((...args: infer Args extends ReadonlyArray<any>) => infer A) ? (...args: Readonly<Args>) => Effect<A, never, Self> : Type[k] extends Effect<infer A, infer E, infer R> ? Effect<A, E, Self | R> : Effect<Type[k], never, Self> };
+}
+/**
+ * Creates a unique tag for a dependency, embedding the service's methods as
+ * static properties.
+ *
+ * **Details**
+ *
+ * This function allows you to define a `Tag` for a service or dependency in
+ * your application. The `Tag` not only acts as an identifier but also provides
+ * direct access to the service's methods via static properties. This makes it
+ * easier to access and use the service in your code without manually managing
+ * contexts.
+ *
+ * In the example below, the fields of the service (in this case, the `notify`
+ * method) are turned into static properties of the Notifications class, making
+ * it easier to access them.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * class Notifications extends Effect.Tag("Notifications")<
+ *   Notifications,
+ *   { readonly notify: (message: string) => Effect.Effect<void> }
+ * >() {}
+ *
+ * // Create an effect that depends on the Notifications service
+ * const action = Notifications.notify("Hello, world!")
+ * ```
+ *
+ * @since 2.0.0
+ * @category Context
+ */
+declare const Tag$1: <const Id extends string>(id: Id) => <Self, Type extends Tag$1.AllowedType>() => TagClass<Self, Id, Type> & (Type extends Record<PropertyKey, any> ? Tag$1.Proxy<Self, Type> : {}) & {
+  use: <X>(body: (_: Type) => X) => [X] extends [Effect<infer A, infer E, infer R>] ? Effect<A, E, R | Self> : [X] extends [PromiseLike<infer A>] ? Effect<A, UnknownException, Self> : Effect<X, never, Self>;
+};
 //#endregion
-//#region src/core/envelope.d.ts
-type EnvelopeKind = 'post' | 'note';
-interface ParsedEnvelope {
-  kind: EnvelopeKind;
-  meta: Record<string, unknown>;
-  contentXml: string;
-  sourceMap: Record<string, number>;
-}
-declare function flagToTag(flag: string): string;
-declare function tagToFlag(tag: string): string;
-declare function parseEnvelope(xml: string, kind: EnvelopeKind): ParsedEnvelope;
-interface EnvelopeMeta {
-  title?: string;
-  slug?: string;
-  category?: string;
-  topic?: string;
-  state?: 'publish' | 'draft';
-  summary?: string;
-  copyright?: boolean;
-  pin?: string;
-  pinOrder?: number;
-  related?: string[];
-  tags?: string[];
-  mood?: string;
-  weather?: string;
-  publicAt?: string;
-  password?: string;
-  bookmark?: boolean;
-  location?: string;
-  subtitle?: string;
-  order?: number;
-  format?: 'lexical' | 'markdown';
-}
-declare function coerceMeta(raw: Record<string, unknown>): EnvelopeMeta;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Inspectable.d.ts
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface Inspectable {
+  toString(): string;
+  toJSON(): unknown;
+  [NodeInspectSymbol](): unknown;
+}
 //#endregion
-//#region src/core/errors.d.ts
-declare const MxsErrorCode: {
-  readonly Generic: "generic";
-  readonly ArgvParse: "argv.parse";
-  readonly AuthMissing: "auth.missing";
-  readonly AuthExpired: "auth.expired";
-  readonly AuthDenied: "auth.denied";
-  readonly AuthProbe: "auth.probe";
-  readonly NetworkTimeout: "network.timeout";
-  readonly NetworkDns: "network.dns";
-  readonly NetworkRefused: "network.refused";
-  readonly ValidationFailed: "validation.failed";
-  readonly ValidationXml: "validation.xml";
-  readonly ServerError: "server.error";
-  readonly ResourceNotFound: "resource.not_found";
-  readonly ConfigMissingApiUrl: "config.missing.api_url";
-  readonly ConfigMissingToken: "config.missing.token";
-  readonly ConfigMigrationFailed: "config.migration.failed";
-  readonly ProfileNotFound: "profile.not_found";
-  readonly ProfileNoneActive: "profile.none_active";
-  readonly ProfileInvalidName: "profile.invalid_name";
-  readonly ProfileWriteRequiresExplicit: "profile.write_requires_explicit";
-  readonly UpdateDevEnvironment: "update.dev_environment";
-  readonly UpdateTransientInstall: "update.transient_install";
-  readonly UpdatePmUnknown: "update.pm_unknown";
-  readonly UpdateRegistryUnreachable: "update.registry_unreachable";
-  readonly UpdateNodeIncompatible: "update.node_incompatible";
-  readonly UpdateSpawnFailed: "update.spawn_failed";
-  readonly UpdatePermissionDenied: "update.permission_denied";
-};
-type MxsErrorCode = (typeof MxsErrorCode)[keyof typeof MxsErrorCode] | (string & {});
-interface MxsErrorOptions {
-  code: MxsErrorCode;
-  message: string;
-  details?: unknown;
-  hint?: string;
-  cause?: unknown;
-}
-declare class MxsError extends Error {
-  readonly code: MxsErrorCode;
-  readonly details?: unknown;
-  readonly hint?: string;
-  constructor(options: MxsErrorOptions);
-  toJSON(): {
-    hint?: string | undefined;
-    details?: {} | null | undefined;
-    ok: false;
-    code: MxsErrorCode;
-    message: string;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Either.d.ts
+/**
+ * @category models
+ * @since 2.0.0
+ */
+type Either<A, E = never> = Left$1<E, A> | Right$1<E, A>;
+/**
+ * @category symbols
+ * @since 2.0.0
+ */
+declare const TypeId: unique symbol;
+/**
+ * @category symbols
+ * @since 2.0.0
+ */
+type TypeId = typeof TypeId;
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface Left$1<out E, out A> extends Pipeable, Inspectable {
+  readonly _tag: "Left";
+  readonly _op: "Left";
+  readonly left: E;
+  readonly [TypeId]: {
+    readonly _R: Covariant<A>;
+    readonly _L: Covariant<E>;
   };
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: EitherUnify<this>;
+  [ignoreSymbol]?: EitherUnifyIgnore;
 }
-declare function exitCodeForError(err: unknown): number;
-//#endregion
-//#region src/core/litexml-codec.d.ts
-interface LexicalState {
-  root: {
-    type: 'root';
-    children: unknown[];
-    direction?: 'ltr' | 'rtl' | null;
-    format?: string;
-    indent?: number;
-    version?: number;
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface Right$1<out E, out A> extends Pipeable, Inspectable {
+  readonly _tag: "Right";
+  readonly _op: "Right";
+  readonly right: A;
+  readonly [TypeId]: {
+    readonly _R: Covariant<A>;
+    readonly _L: Covariant<E>;
   };
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: EitherUnify<this>;
+  [ignoreSymbol]?: EitherUnifyIgnore;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface EitherUnify<A extends {
+  [typeSymbol]?: any;
+}> {
+  Either?: () => A[typeSymbol] extends Either<infer R0, infer L0> | infer _ ? Either<R0, L0> : never;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface EitherUnifyIgnore {}
+/**
+ * @since 2.0.0
+ */
+declare namespace Either {
+  /**
+   * @since 2.0.0
+   * @category type-level
+   */
+  type Left<T extends Either<any, any>> = [T] extends [Either<infer _A, infer _E>] ? _E : never;
+  /**
+   * @since 2.0.0
+   * @category type-level
+   */
+  type Right<T extends Either<any, any>> = [T] extends [Either<infer _A, infer _E>] ? _A : never;
 }
-declare function parseToLexical(xml: string): LexicalState;
-declare function serializeFromLexical(state: LexicalState): string;
-declare function deriveTextFromLexical(state: LexicalState): string;
-declare function emptyLexicalState(): LexicalState;
 //#endregion
-//#region src/core/onboarding.d.ts
-interface OnboardingResult {
-  apiUrl: string;
-  apiBase: string;
-  authBase: string;
-  apiVersion: number;
-}
-interface OnboardingOptions {
-  http?: AuthHttp;
-  initialApiUrl?: string;
-  isTTY?: boolean;
-  prompt?: (question: string) => Promise<string>;
-  /** Override the target profile name (mirrors --profile flag). */
-  profile?: string;
-}
-declare function runOnboarding(opts?: OnboardingOptions): Promise<OnboardingResult>;
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Channel.d.ts
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+declare const ChannelTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+type ChannelTypeId = typeof ChannelTypeId;
+/**
+ * A `Channel` is a nexus of I/O operations, which supports both reading and
+ * writing. A channel may read values of type `InElem` and write values of type
+ * `OutElem`. When the channel finishes, it yields a value of type `OutDone`. A
+ * channel may fail with a value of type `OutErr`.
+ *
+ * Channels are the foundation of Streams: both streams and sinks are built on
+ * channels. Most users shouldn't have to use channels directly, as streams and
+ * sinks are much more convenient and cover all common use cases. However, when
+ * adding new stream and sink operators, or doing something highly specialized,
+ * it may be useful to use channels directly.
+ *
+ * Channels compose in a variety of ways:
+ *
+ *  - **Piping**: One channel can be piped to another channel, assuming the
+ *    input type of the second is the same as the output type of the first.
+ *  - **Sequencing**: The terminal value of one channel can be used to create
+ *    another channel, and both the first channel and the function that makes
+ *    the second channel can be composed into a channel.
+ *  - **Concatenating**: The output of one channel can be used to create other
+ *    channels, which are all concatenated together. The first channel and the
+ *    function that makes the other channels can be composed into a channel.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+interface Channel<out OutElem, in InElem = unknown, out OutErr = never, in InErr = unknown, out OutDone = void, in InDone = unknown, out Env = never> extends Channel.Variance<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, Pipeable {
+  [typeSymbol]?: unknown;
+  [unifySymbol]?: ChannelUnify<this>;
+  [ignoreSymbol]?: ChannelUnifyIgnore;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+interface ChannelUnify<A extends {
+  [typeSymbol]?: any;
+}> extends EffectUnify<A> {
+  Channel?: () => A[typeSymbol] extends Channel<infer OutElem, infer InElem, infer OutErr, infer InErr, infer OutDone, infer InDone, infer Env> | infer _ ? Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> : never;
+}
+/**
+ * @category models
+ * @since 2.0.0
+ */
+interface ChannelUnifyIgnore extends EffectUnifyIgnore {
+  Channel?: true;
+}
+/**
+ * @since 2.0.0
+ * @category models
+ */
+declare module "./Effect.js" {
+  interface Effect<A, E, R> extends Channel<never, unknown, E, unknown, A, unknown, R> {}
+  interface EffectUnifyIgnore {
+    Channel?: true;
+  }
+}
+/**
+ * @since 2.0.0
+ */
+declare namespace Channel {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface Variance<out OutElem, in InElem, out OutErr, in InErr, out OutDone, in InDone, out Env> {
+    readonly [ChannelTypeId]: VarianceStruct<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>;
+  }
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  interface VarianceStruct<out OutElem, in InElem, out OutErr, in InErr, out OutDone, in InDone, out Env> {
+    _Env: Covariant<Env>;
+    _InErr: Contravariant<InErr>;
+    _InElem: Contravariant<InElem>;
+    _InDone: Contravariant<InDone>;
+    _OutErr: Covariant<OutErr>;
+    _OutElem: Covariant<OutElem>;
+    _OutDone: Covariant<OutDone>;
+  }
+}
 //#endregion
-//#region src/core/payload.d.ts
-type ContentFormat = 'lexical' | 'markdown';
-interface PostFlagInputs {
-  title?: string;
-  slug?: string;
-  category?: string;
-  content?: string;
-  format?: ContentFormat;
-  summary?: string;
-  state?: 'publish' | 'draft';
-  tags?: string[];
-  copyright?: boolean;
-  pin?: string;
-  pinOrder?: number;
-  related?: string[];
-  meta?: string;
-  file?: string;
-}
-interface NoteFlagInputs {
-  title?: string;
-  slug?: string;
-  topic?: string;
-  content?: string;
-  format?: ContentFormat;
-  state?: 'publish' | 'draft';
-  mood?: string;
-  weather?: string;
-  publicAt?: string;
-  password?: string;
-  bookmark?: boolean;
-  coords?: string;
-  location?: string;
-  images?: string;
-  meta?: string;
-  file?: string;
-}
-interface PageFlagInputs {
-  title?: string;
-  slug?: string;
-  subtitle?: string;
-  order?: number;
-  content?: string;
-  format?: ContentFormat;
-  meta?: string;
-  file?: string;
-}
-interface BuiltPayload {
-  payload: Record<string, unknown>;
-  envelopeMeta?: EnvelopeMeta;
-  contentSource?: 'flag' | 'envelope' | 'none';
-}
-declare function buildPostPayload(flags: PostFlagInputs): Promise<BuiltPayload>;
-declare function buildNotePayload(flags: NoteFlagInputs): Promise<BuiltPayload>;
-declare function buildPagePayload(flags: PageFlagInputs): Promise<BuiltPayload>;
-declare function emptyPayload(format: ContentFormat): {
-  content: string;
-  text: string;
-};
+//#region ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/dts/Cause.d.ts
+/**
+ * A unique symbol identifying the `NoSuchElementException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies a `NoSuchElementException`. It helps
+ * differentiate cases where a required element is missing within a data
+ * structure.
+ *
+ * @see {@link NoSuchElementException} Create or work with a `NoSuchElementException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+declare const NoSuchElementExceptionTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category Symbols
+ */
+type NoSuchElementExceptionTypeId = typeof NoSuchElementExceptionTypeId;
+/**
+ * A unique symbol identifying the `UnknownException` type.
+ *
+ * **Details**
+ *
+ * This provides a symbol that identifies an `UnknownException`. It is typically
+ * used for generic or unexpected errors that do not fit other specific
+ * exception categories.
+ *
+ * @see {@link UnknownException} Create or work with an `UnknownException`
+ *
+ * @since 2.0.0
+ * @category Symbols
+ */
+declare const UnknownExceptionTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category Symbols
+ */
+type UnknownExceptionTypeId = typeof UnknownExceptionTypeId;
+/**
+ * Represents an error object that can be yielded in `Effect.gen`.
+ *
+ * @since 2.0.0
+ * @category Models
+ */
+interface YieldableError extends Pipeable, Inspectable, Error {
+  readonly [EffectTypeId]: Effect.VarianceStruct<never, this, never>;
+  readonly [StreamTypeId]: Stream.VarianceStruct<never, this, never>;
+  readonly [SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>;
+  readonly [ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>;
+  [Symbol.iterator](): EffectGenerator<Effect<never, this, never>>;
+}
+/**
+ * Creates an error that occurs at runtime, extendable for other exception
+ * types.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+declare const YieldableError: new (message?: string | undefined) => YieldableError;
+/**
+ * An error that occurs when an expected element is missing.
+ *
+ * **Details**
+ *
+ * This interface indicates scenarios like looking up an item in a collection
+ * or searching for data that should be present but isn't. It helps your code
+ * signal a more specific issue rather than a general error.
+ *
+ * @since 2.0.0
+ * @category Models
+ */
+interface NoSuchElementException extends YieldableError {
+  readonly _tag: "NoSuchElementException";
+  readonly [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId;
+}
+/**
+ * A checked exception for handling unknown or unexpected errors.
+ *
+ * **Details**
+ *
+ * This interface captures errors that don't fall under known categories. It is
+ * especially helpful for wrapping low-level or third-party library errors that
+ * might provide little or no context, such as from a rejected promise.
+ *
+ * @since 2.0.0
+ * @category Models
+ */
+interface UnknownException extends YieldableError {
+  readonly _tag: "UnknownException";
+  readonly [UnknownExceptionTypeId]: UnknownExceptionTypeId;
+  readonly error: unknown;
+}
+/**
+ * Creates an error indicating a missing element.
+ *
+ * **Details**
+ *
+ * This function constructs a `NoSuchElementException`. It helps you clearly
+ * communicate that a required element is unavailable.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+declare const NoSuchElementException: new (message?: string | undefined) => NoSuchElementException;
+/**
+ * Creates an instance of `UnknownException`, an error object used to handle
+ * unknown errors such as those from rejected promises.
+ *
+ * **Details**
+ *
+ * This function constructs an `UnknownException` with flexible behavior for
+ * managing the error message and cause.
+ *
+ * The required `error` argument is passed as the `cause` to the global `Error`
+ * constructor, ensuring that the original cause is preserved in the error chain
+ * for debugging purposes. This ensures that the origin stack trace is
+ * preserved.
+ *
+ * The `error` argument is always stored in the `error` property of the
+ * `UnknownException` instance for reference, regardless of its type.
+ *
+ * Additionally, if you provide a `message` argument, it is used as the error
+ * message. If no `message` is provided, the error message defaults to `"An
+ * unknown error occurred"`.
+ *
+ * **When to Use**
+ *
+ * Use this function when you need to handle unexpected or unknown errors in
+ * your application, particularly when the source of the error might not provide
+ * a clear message. This is useful for wrapping generic errors thrown from
+ * promises or external APIs.
+ *
+ * @since 2.0.0
+ * @category Errors
+ */
+declare const UnknownException: new (error: unknown, message?: string | undefined) => UnknownException;
 //#endregion
-//#region src/core/resolve.d.ts
-interface ResolvableItem {
-  id: string;
-  slug?: string;
-  name?: string;
-}
-interface ResolverFetchers {
-  fetchCategories?: () => Promise<ResolvableItem[]>;
-  fetchTopics?: () => Promise<ResolvableItem[]>;
-}
-declare function isSnowflakeId(value: string): boolean;
-declare class NameResolver {
-  private fetchers;
-  private cache;
-  private ttlMs;
-  constructor(fetchers: ResolverFetchers, {
-    ttlMs
-  }?: {
-    ttlMs?: number;
-  });
-  resolveCategory(value: string): Promise<string>;
-  resolveTopic(value: string): Promise<string>;
-  invalidate(kind?: string): void;
-  private resolveWith;
-  private load;
-}
-declare function matchItem(items: ReadonlyArray<ResolvableItem>, value: string): ResolvableItem | null;
-declare function levenshtein(a: string, b: string): number;
-declare function fuzzySuggest(items: ReadonlyArray<ResolvableItem>, value: string, maxDistance?: number): string[];
+//#region src/domain/errors.d.ts
+declare const AuthMissing_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "AuthMissing";
+} & Readonly<A>;
+declare class AuthMissing extends AuthMissing_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const AuthExpired_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "AuthExpired";
+} & Readonly<A>;
+declare class AuthExpired extends AuthExpired_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const AuthDenied_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "AuthDenied";
+} & Readonly<A>;
+declare class AuthDenied extends AuthDenied_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const AuthProbe_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "AuthProbe";
+} & Readonly<A>;
+declare class AuthProbe extends AuthProbe_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+  readonly cause?: unknown;
+}> {}
+declare const NetworkTimeout_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "NetworkTimeout";
+} & Readonly<A>;
+declare class NetworkTimeout extends NetworkTimeout_base<{
+  readonly message?: string;
+  readonly url?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const NetworkDns_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "NetworkDns";
+} & Readonly<A>;
+declare class NetworkDns extends NetworkDns_base<{
+  readonly message?: string;
+  readonly host?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const NetworkRefused_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "NetworkRefused";
+} & Readonly<A>;
+declare class NetworkRefused extends NetworkRefused_base<{
+  readonly message?: string;
+  readonly url?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ValidationFailed_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ValidationFailed";
+} & Readonly<A>;
+declare class ValidationFailed extends ValidationFailed_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ValidationXml_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ValidationXml";
+} & Readonly<A>;
+declare class ValidationXml extends ValidationXml_base<{
+  readonly message?: string;
+  readonly line?: number;
+  readonly details?: unknown;
+  readonly hint?: string;
+  readonly cause?: unknown;
+}> {}
+declare const ServerError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ServerError";
+} & Readonly<A>;
+declare class ServerError extends ServerError_base<{
+  readonly message?: string;
+  readonly status?: number;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ResourceNotFound_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ResourceNotFound";
+} & Readonly<A>;
+declare class ResourceNotFound extends ResourceNotFound_base<{
+  readonly message?: string;
+  readonly kind?: string;
+  readonly ref?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ConfigMissingApiUrl_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ConfigMissingApiUrl";
+} & Readonly<A>;
+declare class ConfigMissingApiUrl extends ConfigMissingApiUrl_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ConfigMissingToken_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ConfigMissingToken";
+} & Readonly<A>;
+declare class ConfigMissingToken extends ConfigMissingToken_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ConfigMigrationFailed_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ConfigMigrationFailed";
+} & Readonly<A>;
+declare class ConfigMigrationFailed extends ConfigMigrationFailed_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+  readonly cause?: unknown;
+}> {}
+declare const ProfileNotFound_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ProfileNotFound";
+} & Readonly<A>;
+declare class ProfileNotFound extends ProfileNotFound_base<{
+  readonly message?: string;
+  readonly name?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ProfileNoneActive_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ProfileNoneActive";
+} & Readonly<A>;
+declare class ProfileNoneActive extends ProfileNoneActive_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ProfileInvalidName_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ProfileInvalidName";
+} & Readonly<A>;
+declare class ProfileInvalidName extends ProfileInvalidName_base<{
+  readonly message?: string;
+  readonly name?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const WriteRequiresExplicit_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "WriteRequiresExplicit";
+} & Readonly<A>;
+declare class WriteRequiresExplicit extends WriteRequiresExplicit_base<{
+  readonly message?: string;
+  readonly profile?: string;
+  readonly apiUrl?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdateDevEnvironment_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdateDevEnvironment";
+} & Readonly<A>;
+declare class UpdateDevEnvironment extends UpdateDevEnvironment_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdateTransientInstall_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdateTransientInstall";
+} & Readonly<A>;
+declare class UpdateTransientInstall extends UpdateTransientInstall_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdatePmUnknown_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdatePmUnknown";
+} & Readonly<A>;
+declare class UpdatePmUnknown extends UpdatePmUnknown_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdateRegistryUnreachable_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdateRegistryUnreachable";
+} & Readonly<A>;
+declare class UpdateRegistryUnreachable extends UpdateRegistryUnreachable_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdateNodeIncompatible_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdateNodeIncompatible";
+} & Readonly<A>;
+declare class UpdateNodeIncompatible extends UpdateNodeIncompatible_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdateSpawnFailed_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdateSpawnFailed";
+} & Readonly<A>;
+declare class UpdateSpawnFailed extends UpdateSpawnFailed_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const UpdatePermissionDenied_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "UpdatePermissionDenied";
+} & Readonly<A>;
+declare class UpdatePermissionDenied extends UpdatePermissionDenied_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const ArgvParse_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "ArgvParse";
+} & Readonly<A>;
+declare class ArgvParse extends ArgvParse_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}> {}
+declare const Generic_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
+  readonly _tag: "Generic";
+} & Readonly<A>;
+declare class Generic extends Generic_base<{
+  readonly message?: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+  readonly cause?: unknown;
+}> {}
+type CliError = AuthMissing | AuthExpired | AuthDenied | AuthProbe | NetworkTimeout | NetworkDns | NetworkRefused | ValidationFailed | ValidationXml | ServerError | ResourceNotFound | ConfigMissingApiUrl | ConfigMissingToken | ConfigMigrationFailed | ProfileNotFound | ProfileNoneActive | ProfileInvalidName | WriteRequiresExplicit | UpdateDevEnvironment | UpdateTransientInstall | UpdatePmUnknown | UpdateRegistryUnreachable | UpdateNodeIncompatible | UpdateSpawnFailed | UpdatePermissionDenied | ArgvParse | Generic;
+type CliErrorTag = CliError['_tag'];
+declare const tagToCode: Record<CliErrorTag, string>;
+declare const codeForTag: (tag: CliErrorTag) => string;
+declare const exitCodeForTag: (tag: CliErrorTag) => number;
+declare const exitCodeForError: (err: unknown) => number;
+declare const defaultMessageFor: (tag: CliErrorTag) => string;
+interface ErrorEnvelope {
+  readonly ok: false;
+  readonly code: string;
+  readonly message: string;
+  readonly details?: unknown;
+  readonly hint?: string;
+}
+declare const toErrorEnvelope: (err: CliError) => ErrorEnvelope;
+//#endregion
+//#region src/services/Renderer.d.ts
+type OutputMode = 'pretty-json' | 'json' | 'readable' | 'llm' | 'envelope';
+interface OutputOptions {
+  readonly json: boolean;
+  readonly output: OutputMode;
+  readonly quiet: boolean;
+  readonly verbose: boolean;
+}
+//#endregion
+//#region src/domain/runtime-flags.d.ts
+interface GlobalFlags {
+  readonly json: boolean;
+  readonly output: OutputMode;
+  readonly apiUrl?: string;
+  readonly token?: string;
+  readonly apiKey?: string;
+  readonly lang?: string;
+  readonly quiet: boolean;
+  readonly verbose: boolean;
+  readonly dryRun: boolean;
+  readonly profile?: string;
+}
+declare const defaultGlobalFlags: GlobalFlags;
+/**
+ * Walk `argv` once, extracting recognized global flags and returning both the
+ * resolved `GlobalFlags` and the residual `argv` (with those flags removed).
+ *
+ * Unknown flags pass through untouched — `@effect/cli` will surface them at
+ * the proper command layer.
+ *
+ * Notes:
+ *   - Both `--key value` and `--key=value` are supported for value flags.
+ *   - argv[0] (node) and argv[1] (script) pass through unchanged.
+ *   - We stop processing global flags at the first `--` (POSIX convention).
+ */
+declare const parseGlobalFlags: (argv: readonly string[]) => {
+  readonly flags: GlobalFlags;
+  readonly rest: readonly string[];
+};
 //#endregion
-export { ApiClient, type ApiClientContext, type ApiResponse, type AuthHttp, type BuiltPayload, type ConfigShape, type ContentFormat, type ContentSource, type CredentialsShape, type DeviceCodeResponse, type DeviceTokenResponse, type DocumentKind, type EnvelopeKind, type EnvelopeMeta, type LexicalState, MxsError, MxsErrorCode, type MxsErrorOptions, NameResolver, type NoteFlagInputs, type OnboardingResult, type OutputOptions, type PageFlagInputs, type ParsedEnvelope, type PostFlagInputs, type ProbeResult, type RequestOptions, type ResolvableItem, type ResolvedConfig, type ResolverFetchers, SUPPORTED_API_VERSIONS, buildNotePayload, buildPagePayload, buildPostPayload, coerceMeta, createApiClient, defaultOutputOptions, deleteCredentials, deriveTextFromLexical, emitDocument, emitError, emitInfo, emitPostList, emitSuccess, emitWarn, emptyLexicalState, emptyPayload, enforceCredentialsMode, ensureFreshToken, exitCodeForError, flagToTag, fuzzySuggest, getConfigDir, getConfigPath, getCredentialsPath, isExpiringSoon, isSnowflakeId, levenshtein, loadCredentialsOrThrow, matchItem, normalizeApiUrl, parseEnvelope, parseToLexical, pollDeviceToken, probeAuthEndpoint, readConfig, readContentSpec, readCredentials, readJsonSpec, refreshAccessToken, renderDocumentEnvelope, renderPostList, renderReadableDocument, renderTable, requestDeviceCode, resolveConfig, runEditorRoundTrip, runOnboarding, serializeFromLexical, tagToFlag, toCredentials, writeConfig, writeCredentials };
-//# sourceMappingURL=index.d.mts.map
+export { type CliError, type CliErrorTag, type ErrorEnvelope, type GlobalFlags, type OutputMode, type OutputOptions, codeForTag, defaultGlobalFlags, defaultMessageFor, exitCodeForError, exitCodeForTag, parseGlobalFlags, run, tagToCode, toErrorEnvelope };