@morlay/ui-conversation-message-actions 0.0.14 → 0.0.16

package/dist/testing.d.mts

@@ -1,9 +1,11 @@
 import { SessionEditor } from "./index.mjs";
 import { Context, Service } from "@deepseek-ai/cordis";
-import { Session, Session as Session$1, SessionEvent, SessionEvent as SessionEvent$1, SessionHeader, SessionHeader as SessionHeader$1, SessionId, SessionId as SessionIdBrand, SessionLogOffset, SessionSeq, SessionStore } from "@deepseek-ai/dsh-session";
+import { Session, Session as Session$1, SessionEvent, SessionEvent as SessionEvent$1, SessionHeader, SessionHeader as SessionHeader$1, SessionId, SessionId as SessionIdBrand, SessionLogOffset, SessionSeq, SessionSeq as SessionSeq$1, SessionStore } from "@deepseek-ai/dsh-session";
 import { BranchBoundary, BranchTimeline, SessionBranch } from "@morlay/session-branch";
 import { TokenMeter } from "@deepseek-ai/dsh-token-meter";
+import { ProjectionSnapshot, SessionProjectionMap } from "@deepseek-ai/dsh-session-projection";
 import { SessionPersistence, SessionPersistenceRevision, SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { SessionId as SessionId$1 } from "@deepseek-ai/dsh-session/types";
 //#region ../../vendor/deepseek-harness/vendor/cosmokit/lib/types/types.d.ts
 declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
 declare function isArrayBufferSource(value: any): value is Binary.Source;
@@ -25,11 +27,11 @@ type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
 //#endregion
 //#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
 /** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1<Input = unknown, Output = Input> {
+interface StandardTypedV1$1<Input = unknown, Output = Input> {
   /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+  readonly "~standard": StandardTypedV1$1.Props<Input, Output>;
 }
-declare namespace StandardTypedV1 {
+declare namespace StandardTypedV1$1 {
   /** The Standard Typed properties interface. */
   interface Props<Input = unknown, Output = Input> {
     /** The version number of the standard. */
@@ -47,20 +49,20 @@ declare namespace StandardTypedV1 {
     readonly output: Output;
   }
   /** Infers the input type of a Standard Typed. */
-  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  type InferInput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
   /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  type InferOutput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
 /** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
   /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
 }
-declare namespace StandardSchemaV1 {
+declare namespace StandardSchemaV1$1 {
   /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
     /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
   }
   /** The result interface of the validate function. */
   type Result<Output> = SuccessResult<Output> | FailureResult;
@@ -93,11 +95,11 @@ declare namespace StandardSchemaV1 {
     readonly key: PropertyKey;
   }
   /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
   /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
   /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
 }
 //#endregion
 //#region ../../vendor/deepseek-harness/vendor/schemastery/lib/types/index.d.ts
@@ -236,7 +238,7 @@ declare global {
     value?: T;
     refs?: Dict<Schema>;
     preserve?: boolean;
-    '~standard': StandardSchemaV1.Props;
+    '~standard': StandardSchemaV1$1.Props;
     /** Format this schema as a compact TypeScript-like type string. */
     toString(inline?: boolean): string;
     /** Serialize this schema, preserving shared and recursive references. */
@@ -294,39 +296,2577 @@ declare class ValidationError extends TypeError {
 type Schema<S = any, T = S> = Schemastery<S, T>;
 declare const Schema: Schemastery.Static;
 //#endregion
-//#region ../session-rdb/src/import.d.ts
-declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
-  events: SessionEvent$1[];
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/json-schema.d.cts
+type _JSONSchema = boolean | JSONSchema;
+type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+type JSONSchema = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema>;
+  type?: SchemaType | SchemaType[];
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema;
+  _prefault?: unknown;
 };
+type BaseSchema = JSONSchema;
 //#endregion
-//#region ../../vendor/deepseek-harness/packages/settings/settings/lib/types/redact.d.ts
-/** One schema-declared secret position inside a redacted value. */
-interface RedactedSecret {
-  /** Path from the section root to the removed field (concrete dict keys and array indexes included). */
-  path: string[];
-  /** Whether the field held a value before redaction. */
-  set: boolean;
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/standard-schema.d.cts
+/** The Standard interface. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
+interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {}
 //#endregion
-//#region ../../vendor/deepseek-harness/packages/util/brand/lib/types/index.d.ts
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/registries.d.cts
+declare const $output: unique symbol;
+type $output = typeof $output;
+declare const $input: unique symbol;
+type $input = typeof $input;
+type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S>; }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S>; } : Meta;
+type MetadataType = object | undefined;
+declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+  _meta: Meta;
+  _schema: Schema;
+  _map: WeakMap<Schema, $replace<Meta, Schema>>;
+  _idmap: Map<string, Schema>;
+  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+  clear(): this;
+  remove(schema: Schema): this;
+  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
+  has(schema: Schema): boolean;
+}
+interface JSONSchemaMeta {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+interface GlobalMeta extends JSONSchemaMeta {}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/to-json-schema.d.cts
+type Processor<T extends $ZodType = $ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void;
 /**
- * Duplicate-install-safe nominal primitive helpers.
- *
- * A brand makes structurally identical strings or numbers non-interchangeable
- * at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
- * expected, and an event sequence cannot be passed as a log offset. Comparison,
- * logging, and serialization retain the underlying primitive behavior.
- *
- * This package owns no concrete domain value and keeps no runtime identity or mutable
- * state, so independently installed copies produce interchangeable values.
- *
- * @module @deepseek-ai/dsh-brand
+ * Called for each schema that has no JSON Schema equivalent. Return a JSON Schema to use in its
+ * place, `"any"` to fall back to the `unrepresentable: "any"` behavior, or `"throw"`/`undefined` to
+ * throw the default error. Throwing from the handler propagates, so custom errors work too.
  */
-declare const BRAND: unique symbol;
-/** A string carrying a compile-time-only brand `B`. */
-type Branded<B extends string> = string & {
-  readonly [BRAND]: B;
+type UnrepresentableHandler<T extends $ZodType = $ZodType> = (ctx: {
+  zodSchema: T;
+  path: (string | number)[];
+  /** The error Zod would throw. Distinguishes sites that share a `zodSchema`, e.g. an `undefined`
+   *  vs a `bigint` member of the same literal. */
+  message: string;
+}) => BaseSchema | "throw" | "any" | undefined;
+interface JSONSchemaGeneratorParams {
+  processors: Record<string, Processor>;
+  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+   *  @default globalRegistry */
+  metadata?: $ZodRegistry<Record<string, any>>;
+  /** The JSON Schema version to target.
+   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+   * - `"draft-07"` — JSON Schema Draft 7
+   * - `"draft-04"` — JSON Schema Draft 4
+   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
+  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
+  /** How to handle unrepresentable types.
+   * - `"throw"` — Default. Unrepresentable types throw an error
+   * - `"any"` — Unrepresentable types become `{}`
+   * - A function — called once per unrepresentable schema; see {@link UnrepresentableHandler}. */
+  unrepresentable?: "throw" | "any" | UnrepresentableHandler<$ZodTypes>;
+  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+  override?: (ctx: {
+    zodSchema: $ZodTypes;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
+   * - `"output"` — Default. Convert the output schema.
+   * - `"input"` — Convert the input schema. */
+  io?: "input" | "output";
+  cycles?: "ref" | "throw";
+  reused?: "ref" | "inline";
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+/**
+ * Parameters for the toJSONSchema function.
+ */
+type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
+interface ProcessParams {
+  schemaPath: $ZodType[];
+  path: (string | number)[];
+}
+interface Seen {
+  /** JSON Schema result for this Zod schema */
+  schema: BaseSchema;
+  /** A cached version of the schema that doesn't get overwritten during ref resolution */
+  def?: BaseSchema;
+  defId?: string | undefined;
+  /** Number of times this schema was encountered during traversal */
+  count: number;
+  /** Cycle path */
+  cycle?: (string | number)[] | undefined;
+  isParent?: boolean | undefined;
+  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
+  ref?: $ZodType | null;
+  /** JSON Schema property path for this schema */
+  path?: (string | number)[] | undefined;
+}
+interface ToJSONSchemaContext {
+  processors: Record<string, Processor>;
+  metadataRegistry: $ZodRegistry<Record<string, any>>;
+  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
+  unrepresentable: "throw" | "any" | UnrepresentableHandler;
+  override: (ctx: {
+    zodSchema: $ZodType;
+    jsonSchema: BaseSchema;
+    path: (string | number)[];
+  }) => void;
+  io: "input" | "output";
+  counter: number;
+  seen: Map<$ZodType, Seen>;
+  /** Registry conversions share one `seen` map across every emitted schema. These hold the
+   * `external` the whole-map passes below last ran for, so the passes are not repeated once per
+   * schema — and still re-run if the map grows or `external` is swapped. `sharedEmitDoneFor`
+   * covers both passes in `finalize`: the ref flattening and the `$defs` build.
+   *
+   * The passes are valid only while nothing they read has changed, so both are cleared in
+   * `processSchema()` when the map grows, and in `JSONSchemaGenerator.emit()`, which can also change
+   * the `cycles` and `reused` they branch on.
+   *
+   * One case is deliberately not covered: an `override` callback that writes to
+   * `metadataRegistry` mid-conversion. It runs inside `finalize`, so a registry conversion has
+   * nowhere left to clear the guards, and later schemas keep the ids the first pass saw. That
+   * output was never coherent — before this, whether a shared subschema was inlined or extracted
+   * depended on which registry entry happened to be emitted when the callback fired. */
+  sharedDefsExtractedFor?: ToJSONSchemaContext["external"];
+  sharedEmitDoneFor?: ToJSONSchemaContext["external"];
+  cycles: "ref" | "throw";
+  reused: "ref" | "inline";
+  /** The `allOf` array of each intersection encountered during traversal, innermost first. `finalize` folds every emitted object holding one; see `foldIntersection`. */
+  intersections: BaseSchema[][];
+  /** Rewrites a processor deferred to `finalize`, where the flatten has resolved every ref and the union branches are in place. */
+  deferred: (() => void)[];
+  external?: {
+    registry: $ZodRegistry<{
+      id?: string | undefined;
+    }>;
+    uri?: ((id: string) => string) | undefined;
+    defs: Record<string, BaseSchema>;
+  } | undefined;
+}
+type ZodStandardSchemaWithJSON$1<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface ZodStandardJSONSchemaPayload<T> extends BaseSchema {
+  "~standard": ZodStandardSchemaWithJSON$1<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/util.d.cts
+type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Omit$1<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type MakePartial<T, K extends keyof T> = Omit$1<T, K> & InexactPartial<Pick<T, K>>;
+type NoUndefined<T> = T extends undefined ? never : T;
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
+type LoosePartial<T extends object> = InexactPartial<T> & {
+  [k: string]: unknown;
+};
+type InexactPartial<T> = { [P in keyof T]?: T[P] | undefined; };
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [k in keyof T]: T[k]; }>;
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+type TupleItems = ReadonlyArray<SomeType>;
+type AnyFunc = (...args: any[]) => any;
+type MaybeAsync<T> = T | Promise<T>;
+type EnumValue = string | number;
+type EnumLike = Readonly<Record<string, EnumValue>>;
+type Literal = string | number | bigint | boolean | null | undefined;
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+type HasLength = {
+  length: number;
+};
+type PropValues = Record<string, Set<Primitive>>;
+type PrimitiveSet = Set<Primitive>;
+type EmptyToNever<T> = keyof T extends never ? never : T;
+declare abstract class Class {
+  constructor(..._args: any[]);
+}
+/** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
+type ProtoOf<T> = { [K in keyof T]?: (T[K] extends ((...args: infer A) => infer R) ? (...args: A) => R : T[K]) | undefined; } & ThisType<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/versions.d.cts
+declare const version: {
+  readonly major: 4;
+  readonly minor: 6;
+  readonly patch: number;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/schemas.d.cts
+interface ParseContext<T extends $ZodIssueBase = never> {
+  /** Customize error messages. */
+  readonly error?: $ZodErrorMap<T>;
+  /** Include the `input` field in issue objects. Default `false`. */
+  readonly reportInput?: boolean;
+  /** Skip eval-based fast path. Default `false`. */
+  readonly jitless?: boolean;
+}
+/** @internal */
+interface ParseContextInternal<T extends $ZodIssueBase = never> extends ParseContext<T> {
+  readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
+  /** Set only by `validate`/`validateAsync`. A container may stop before its next child, never inside one, so a map entry and a tuple's fixed items parse whole. */
+  readonly abortEarly?: boolean;
+}
+interface ParsePayload<T = unknown> {
+  value: T;
+  issues: $ZodRawIssue[];
+  /** A way to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
+  /** @internal Set when the value came from a repeat visit to a node still being
+   * parsed. Its checks run on the node itself, against the finished value. */
+  memo?: boolean | undefined;
+}
+type CheckFn<T> = (input: ParsePayload<T>) => MaybeAsync<void>;
+interface $ZodTypeDef {
+  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom" | "properties";
+  error?: $ZodErrorMap<never> | undefined;
+  checks?: $ZodCheck<never>[];
+}
+interface _$ZodTypeInternals {
+  /** The `@zod/core` version of this schema */
+  version: typeof version;
+  /** Schema definition. */
+  def: $ZodTypeDef;
+  /** @internal Randomly generated ID for this schema. */
+  /** @internal List of deferred initializers. */
+  deferred: AnyFunc[] | undefined;
+  /** @internal Parses input and runs all checks (refinements). */
+  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal Parses input, doesn't run checks. */
+  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
+  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+  traits: Set<string>;
+  /** @internal Indicates that a schema output type should be considered optional inside objects.
+   * @default Required
+   */
+  /** @internal Three rungs, each strictly stronger than the last:
+   *   undefined    — required; the container may not omit this slot
+   *   "optional"   — the container may omit it; nothing is supplied in its place
+   *   "defaulted"  — the container may omit it AND this schema substitutes a value
+   * Consumers asking "may the slot be absent?" test `!== undefined`.
+   * $ZodOptional asks the stronger question and tests `=== "defaulted"`. */
+  optin?: "optional" | "defaulted" | undefined;
+  /** @internal */
+  optout?: "optional" | undefined;
+  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+   *
+   * Defined on: enum, const, literal, null, undefined
+   * Passthrough: optional, nullable, branded, default, catch, pipe
+   * Todo: unions?
+   */
+  values?: PrimitiveSet | undefined;
+  /** Default value bubbled up from  */
+  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+  propValues?: PropValues | undefined;
+  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+  pattern: RegExp | undefined;
+  /** @internal The constructor function of this schema. */
+  constr: new (def: any) => $ZodType;
+  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+  bag: Record<string, unknown>;
+  /** @internal The set of issues this schema might throw during type checking. */
+  isst: $ZodIssueBase;
+  /** @internal Subject to change, not a public API. */
+  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
+  /** An optional method used to override `toJSONSchema` logic. */
+  toJSONSchema?: () => unknown;
+  /** @internal The parent of this schema. Only set during certain clone operations. */
+  parent?: $ZodType | undefined;
+}
+/** @internal */
+interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+  /** @internal The inferred output type */
+  output: O;
+  /** @internal The inferred input type */
+  input: I;
+}
+type $ZodStandardSchema<T> = StandardSchemaV1.Props<input<T>, output<T>>;
+type SomeType = {
+  _zod: _$ZodTypeInternals;
+};
+interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+  _zod: Internals;
+  "~standard": $ZodStandardSchema<this>;
+}
+interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {}
+declare const $ZodType: $constructor<$ZodType>;
+interface $ZodStringDef extends $ZodTypeDef {
+  type: "string";
+  coerce?: boolean;
+  checks?: $ZodCheck<string>[];
+}
+interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
+  def: $ZodStringDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    patterns: Set<RegExp>;
+    format: string;
+    contentEncoding: string;
+    /** the pattern admits strings its `format` keyword forbids, so `toJSONSchema` must not emit it */
+    laxFormat: boolean;
+  }>;
+}
+interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
+declare const $ZodString: $constructor<$ZodString>;
+interface $ZodNumberDef extends $ZodTypeDef {
+  type: "number";
+  coerce?: boolean;
+}
+interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
+  def: $ZodNumberDef;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    exclusiveMinimum: number;
+    exclusiveMaximum: number;
+    format: string;
+    pattern: RegExp;
+  }>;
+}
+interface $ZodNumber<Input = unknown> extends $ZodType {
+  _zod: $ZodNumberInternals<Input>;
+}
+declare const $ZodNumber: $constructor<$ZodNumber>;
+interface $ZodBooleanDef extends $ZodTypeDef {
+  type: "boolean";
+  coerce?: boolean;
+  checks?: $ZodCheck<boolean>[];
+}
+interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {
+  pattern: RegExp;
+  def: $ZodBooleanDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodBoolean<T = unknown> extends $ZodType {
+  _zod: $ZodBooleanInternals<T>;
+}
+declare const $ZodBoolean: $constructor<$ZodBoolean>;
+interface $ZodBigIntDef extends $ZodTypeDef {
+  type: "bigint";
+  coerce?: boolean;
+}
+interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {
+  pattern: RegExp;
+  /** @internal Internal API, use with caution */
+  def: $ZodBigIntDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: bigint;
+    maximum: bigint;
+    format: string;
+  }>;
+}
+interface $ZodBigInt<T = unknown> extends $ZodType {
+  _zod: $ZodBigIntInternals<T>;
+}
+declare const $ZodBigInt: $constructor<$ZodBigInt>;
+interface $ZodSymbolDef extends $ZodTypeDef {
+  type: "symbol";
+}
+interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
+  def: $ZodSymbolDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodSymbol extends $ZodType {
+  _zod: $ZodSymbolInternals;
+}
+declare const $ZodSymbol: $constructor<$ZodSymbol>;
+interface $ZodUndefinedDef extends $ZodTypeDef {
+  type: "undefined";
+}
+interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
+  pattern: RegExp;
+  def: $ZodUndefinedDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodUndefined extends $ZodType {
+  _zod: $ZodUndefinedInternals;
+}
+declare const $ZodUndefined: $constructor<$ZodUndefined>;
+interface $ZodNullDef extends $ZodTypeDef {
+  type: "null";
+}
+interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
+  pattern: RegExp;
+  def: $ZodNullDef;
+  values: PrimitiveSet;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNull extends $ZodType {
+  _zod: $ZodNullInternals;
+}
+declare const $ZodNull: $constructor<$ZodNull>;
+interface $ZodAnyDef extends $ZodTypeDef {
+  type: "any";
+}
+interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
+  def: $ZodAnyDef;
+  isst: never;
+}
+interface $ZodAny extends $ZodType {
+  _zod: $ZodAnyInternals;
+}
+declare const $ZodAny: $constructor<$ZodAny>;
+interface $ZodUnknownDef extends $ZodTypeDef {
+  type: "unknown";
+}
+interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
+  def: $ZodUnknownDef;
+  isst: never;
+}
+interface $ZodUnknown extends $ZodType {
+  _zod: $ZodUnknownInternals;
+}
+declare const $ZodUnknown: $constructor<$ZodUnknown>;
+interface $ZodNeverDef extends $ZodTypeDef {
+  type: "never";
+}
+interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
+  def: $ZodNeverDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNever extends $ZodType {
+  _zod: $ZodNeverInternals;
+}
+declare const $ZodNever: $constructor<$ZodNever>;
+interface $ZodVoidDef extends $ZodTypeDef {
+  type: "void";
+}
+interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
+  def: $ZodVoidDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodVoid extends $ZodType {
+  _zod: $ZodVoidInternals;
+}
+declare const $ZodVoid: $constructor<$ZodVoid>;
+interface $ZodDateDef extends $ZodTypeDef {
+  type: "date";
+  coerce?: boolean;
+}
+interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {
+  def: $ZodDateDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: Date;
+    maximum: Date;
+    format: string;
+  }>;
+}
+interface $ZodDate<T = unknown> extends $ZodType {
+  _zod: $ZodDateInternals<T>;
+}
+declare const $ZodDate: $constructor<$ZodDate>;
+interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "array";
+  element: T;
+}
+interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodArrayDef<T>;
+  isst: $ZodIssueInvalidType;
+  output: output<T>[];
+  input: input<T>[];
+}
+interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
+declare const $ZodArray: $constructor<$ZodArray>;
+type OptionalOutSchema = {
+  _zod: {
+    optout: "optional";
+  };
+};
+type OptionalInSchema = {
+  _zod: {
+    optin: "optional" | "defaulted";
+  };
+};
+type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: output<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"]; } & { -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"]; } & Extra>;
+type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? IsAny<T[keyof T]> extends true ? Record<string, unknown> : { [k in string]: input<T[keyof T]>; } : keyof (T & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"]; } & { -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"]; } & Extra>;
+type $ZodObjectConfig = {
+  out: Record<string, unknown>;
+  in: Record<string, unknown>;
+};
+type $ZodShape = Readonly<{
+  [k: string]: $ZodType;
+}>;
+interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+  type: "object";
+  shape: Shape;
+  catchall?: $ZodType | undefined;
+}
+interface $ZodObjectInternals<
+/** @ts-ignore Cast variance */
+out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+  def: $ZodObjectDef<Shape>;
+  config: Config;
+  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
+  propValues: PropValues;
+  output: $InferObjectOutput<Shape, Config["out"]>;
+  input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $ZodLooseShape = Record<string, any>;
+interface $ZodObject<
+/** @ts-ignore Cast variance */
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {}
+declare const $ZodObject: $constructor<$ZodObject>;
+type $InferUnionOutput<T extends SomeType> = T extends any ? output<T> : never;
+type $InferUnionInput<T extends SomeType> = T extends any ? input<T> : never;
+interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
+  type: "union";
+  options: Options;
+  inclusive?: boolean;
+}
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
+  def: $ZodUnionDef<T>;
+  isst: $ZodIssueInvalidUnion;
+  pattern: T[number]["_zod"]["pattern"];
+  values: T[number]["_zod"]["values"];
+  output: $InferUnionOutput<T[number]>;
+  input: $InferUnionInput<T[number]>;
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | "defaulted" | undefined : "optional" | "defaulted";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
+  _zod: $ZodUnionInternals<T>;
+}
+declare const $ZodUnion: $constructor<$ZodUnion>;
+interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "intersection";
+  left: Left;
+  right: Right;
+}
+interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
+  def: $ZodIntersectionDef<A, B>;
+  isst: never;
+  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: output<A> & output<B>;
+  input: input<A> & input<B>;
+}
+interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodIntersectionInternals<A, B>;
+}
+declare const $ZodIntersection: $constructor<$ZodIntersection>;
+interface $ZodTupleDef<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
+  type: "tuple";
+  items: T;
+  rest: Rest;
+}
+type $InferTupleInputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleInputTypeWithOptionals<T>, ...(Rest extends SomeType ? input<Rest>[] : [])];
+type TupleInputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: input<T[k]>; };
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+type $InferTupleOutputType<T extends TupleItems, Rest extends SomeType | null> = [...TupleOutputTypeWithOptionals<T>, ...(Rest extends SomeType ? output<Rest>[] : [])];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = { [k in keyof T]: output<T[k]>; };
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+interface $ZodTupleInternals<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
+  def: $ZodTupleDef<T, Rest>;
+  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
+}
+interface $ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
+  _zod: $ZodTupleInternals<T, Rest>;
+}
+declare const $ZodTuple: $constructor<$ZodTuple>;
+type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
+interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "record";
+  keyType: Key;
+  valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
+  partial?: boolean;
+}
+type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<output<Key>, output<Value>>> : Record<output<Key>, output<Value>>;
+type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : [Value] extends [OptionalInSchema] ? Partial<Record<input<Key> & PropertyKey, input<Value>>> : Record<input<Key> & PropertyKey, input<Value>>;
+interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+  def: $ZodRecordDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+type $partial = {
+  "~~partial": true;
 };
+interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodRecordInternals<Key, Value>;
+}
+declare const $ZodRecord: $constructor<$ZodRecord>;
+interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "map";
+  keyType: Key;
+  valueType: Value;
+}
+interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key>, output<Value>>, Map<input<Key>, input<Value>>> {
+  def: $ZodMapDef<Key, Value>;
+  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodMapInternals<Key, Value>;
+}
+declare const $ZodMap: $constructor<$ZodMap>;
+interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "set";
+  valueType: T;
+}
+interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T>>, Set<input<T>>> {
+  def: $ZodSetDef<T>;
+  isst: $ZodIssueInvalidType;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
+}
+interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSetInternals<T>;
+}
+declare const $ZodSet: $constructor<$ZodSet>;
+type $InferEnumOutput<T extends EnumLike> = T[keyof T] & {};
+type $InferEnumInput<T extends EnumLike> = T[keyof T] & {};
+interface $ZodEnumDef<T extends EnumLike = EnumLike> extends $ZodTypeDef {
+  type: "enum";
+  entries: T;
+}
+interface $ZodEnumInternals<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
+  def: $ZodEnumDef<T>;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  values: PrimitiveSet;
+  /** @deprecated Internal API, use with caution (not deprecated) */
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodEnum<T extends EnumLike = EnumLike> extends $ZodType {
+  _zod: $ZodEnumInternals<T>;
+}
+declare const $ZodEnum: $constructor<$ZodEnum>;
+interface $ZodLiteralDef<T extends Literal> extends $ZodTypeDef {
+  type: "literal";
+  values: T[];
+}
+interface $ZodLiteralInternals<T extends Literal = Literal> extends $ZodTypeInternals<T, T> {
+  def: $ZodLiteralDef<T>;
+  values: Set<T>;
+  pattern: RegExp;
+  isst: $ZodIssueInvalidValue;
+}
+interface $ZodLiteral<T extends Literal = Literal> extends $ZodType {
+  _zod: $ZodLiteralInternals<T>;
+}
+declare const $ZodLiteral: $constructor<$ZodLiteral>;
+type _File = typeof globalThis extends {
+  File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+interface File extends _File {
+  readonly type: string;
+  readonly size: number;
+}
+interface $ZodFileDef extends $ZodTypeDef {
+  type: "file";
+}
+interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
+  def: $ZodFileDef;
+  isst: $ZodIssueInvalidType;
+  bag: LoosePartial<{
+    minimum: number;
+    maximum: number;
+    mime: MimeTypes[];
+  }>;
+}
+interface $ZodFile extends $ZodType {
+  _zod: $ZodFileInternals;
+}
+declare const $ZodFile: $constructor<$ZodFile>;
+interface $ZodTransformDef extends $ZodTypeDef {
+  type: "transform";
+  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
+}
+interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
+  def: $ZodTransformDef;
+  isst: never;
+}
+interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodTransformInternals<O, I>;
+}
+declare const $ZodTransform: $constructor<$ZodTransform>;
+interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "optional";
+  innerType: T;
+}
+interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | undefined, input<T> | undefined> {
+  def: $ZodOptionalDef<T>;
+  optin: "optional" | "defaulted";
+  optout: "optional";
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodOptionalInternals<T>;
+}
+declare const $ZodOptional: $constructor<$ZodOptional>;
+interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {}
+interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
+  def: $ZodExactOptionalDef<T>;
+  output: output<T>;
+  input: input<T>;
+}
+interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodExactOptionalInternals<T>;
+}
+declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
+interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nullable";
+  innerType: T;
+}
+interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T> | null, input<T> | null> {
+  def: $ZodNullableDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+  pattern: T["_zod"]["pattern"];
+}
+interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNullableInternals<T>;
+}
+declare const $ZodNullable: $constructor<$ZodNullable>;
+interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "default";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: NoUndefined<output<T>>;
+}
+interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodDefaultDef<T>;
+  optin: "defaulted";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodDefaultInternals<T>;
+}
+declare const $ZodDefault: $constructor<$ZodDefault>;
+interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "prefault";
+  innerType: T;
+  /** The default value. May be a getter. */
+  defaultValue: input<T>;
+}
+interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, input<T> | undefined> {
+  def: $ZodPrefaultDef<T>;
+  optin: "defaulted";
+  optout?: "optional" | undefined;
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPrefaultInternals<T>;
+}
+declare const $ZodPrefault: $constructor<$ZodPrefault>;
+interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "nonoptional";
+  innerType: T;
+}
+interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T>>, NoUndefined<input<T>>> {
+  def: $ZodNonOptionalDef<T>;
+  isst: $ZodIssueInvalidType;
+  values: T["_zod"]["values"];
+  optin: "optional" | undefined;
+  optout: "optional" | undefined;
+}
+interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodNonOptionalInternals<T>;
+}
+declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
+interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "success";
+  innerType: T;
+}
+interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T>> {
+  def: $ZodSuccessDef<T>;
+  isst: never;
+  optin: T["_zod"]["optin"];
+  optout: "optional" | undefined;
+}
+interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodSuccessInternals<T>;
+}
+declare const $ZodSuccess: $constructor<$ZodSuccess>;
+interface $ZodCatchCtx extends ParsePayload {
+  /** @deprecated Use `ctx.issues` */
+  error: {
+    issues: $ZodIssue[];
+  };
+  /** @deprecated Use `ctx.value` */
+  input: unknown;
+}
+interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "catch";
+  innerType: T;
+  catchValue: (ctx: $ZodCatchCtx) => unknown;
+}
+interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodCatchDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  values: T["_zod"]["values"];
+}
+interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCatchInternals<T>;
+}
+declare const $ZodCatch: $constructor<$ZodCatch>;
+interface $ZodNaNDef extends $ZodTypeDef {
+  type: "nan";
+}
+interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
+  def: $ZodNaNDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodNaN extends $ZodType {
+  _zod: $ZodNaNInternals;
+}
+declare const $ZodNaN: $constructor<$ZodNaN>;
+interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "pipe";
+  in: A;
+  out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}
+interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
+  def: $ZodPipeDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPipeInternals<A, B>;
+}
+declare const $ZodPipe: $constructor<$ZodPipe>;
+interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "readonly";
+  innerType: T;
+}
+interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T>>, MakeReadonly<input<T>>> {
+  def: $ZodReadonlyDef<T>;
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+  isst: never;
+  propValues: T["_zod"]["propValues"];
+  values: T["_zod"]["values"];
+}
+interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodReadonlyInternals<T>;
+}
+declare const $ZodReadonly: $constructor<$ZodReadonly>;
+interface $ZodTemplateLiteralDef extends $ZodTypeDef {
+  type: "template_literal";
+  parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
+}
+interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
+  pattern: RegExp;
+  def: $ZodTemplateLiteralDef;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
+  _zod: $ZodTemplateLiteralInternals<Template>;
+}
+type LiteralPart = Exclude<Literal, symbol>;
+interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
+  pattern: RegExp;
+}
+interface SchemaPart extends $ZodType {
+  _zod: SchemaPartInternals;
+}
+type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
+declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
+type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+type $ZodFunctionIn = $ZodFunctionArgs;
+type $ZodFunctionOut = $ZodType;
+type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
+type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
+type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
+type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
+interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: $ZodIssueInvalidType;
+}
+interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+declare const $ZodFunction: $constructor<$ZodFunction>;
+interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "promise";
+  innerType: T;
+}
+interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T>>, MaybeAsync<input<T>>> {
+  def: $ZodPromiseDef<T>;
+  isst: never;
+}
+interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodPromiseInternals<T>;
+}
+declare const $ZodPromise: $constructor<$ZodPromise>;
+interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
+  type: "lazy";
+  getter: () => T;
+}
+interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<output<T>, input<T>> {
+  def: $ZodLazyDef<T>;
+  isst: never;
+  /** Auto-cached way to retrieve the inner schema */
+  innerType: T;
+  pattern: T["_zod"]["pattern"];
+  propValues: T["_zod"]["propValues"];
+  optin: T["_zod"]["optin"];
+  optout: T["_zod"]["optout"];
+}
+interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodLazyInternals<T>;
+}
+declare const $ZodLazy: $constructor<$ZodLazy>;
+interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
+  type: "custom";
+  check: "custom";
+  path?: PropertyKey[] | undefined;
+  error?: $ZodErrorMap | undefined;
+  params?: Record<string, any> | undefined;
+  fn: (arg: O) => unknown;
+}
+interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
+  def: $ZodCustomDef;
+  issc: $ZodIssue;
+  isst: never;
+  bag: LoosePartial<{
+    Class: typeof Class;
+  }>;
+}
+interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
+  _zod: $ZodCustomInternals<O, I>;
+}
+declare const $ZodCustom: $constructor<$ZodCustom>;
+interface $ZodPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef, $ZodCheckDef {
+  type: "properties";
+  check: "properties";
+  shape: Shape;
+}
+interface $ZodPropertiesInternals<Shape extends $ZodShape = $ZodShape> extends $ZodTypeInternals<$InferObjectInput<Shape, {}>, $InferObjectInput<Shape, {}>>, $ZodCheckInternals<{ -readonly [k in keyof Shape]: Widen<input<Shape[k]>>; }> {
+  def: $ZodPropertiesDef<Shape>;
+  isst: $ZodIssueInvalidType;
+  issc: $ZodIssue;
+}
+interface $ZodProperties<Shape extends $ZodShape = $ZodShape> extends $ZodType {
+  _zod: $ZodPropertiesInternals<Shape>;
+  [Symbol.iterator](): Iterator<this>;
+}
+declare const $ZodProperties: $constructor<$ZodProperties>;
+type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodProperties | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/checks.d.cts
+interface $ZodCheckDef {
+  check: string;
+  error?: $ZodErrorMap<never> | undefined;
+  /** If true, no later checks will be executed if this check fails. Default `false`. */
+  abort?: boolean | undefined;
+  /** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheckInternals<T> {
+  def: $ZodCheckDef;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase;
+  check(payload: ParsePayload<T>): MaybeAsync<void>;
+  onattach: ((schema: $ZodType) => void)[];
+}
+interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/errors.d.cts
+interface $ZodIssueBase {
+  readonly code?: string;
+  readonly input?: unknown;
+  readonly path: PropertyKey[];
+  readonly message: string;
+}
+type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
+interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_type";
+  readonly expected: $ZodInvalidTypeExpected;
+  readonly input?: Input;
+}
+interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_big";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly maximum: number | bigint;
+  readonly inclusive?: boolean;
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+  readonly code: "too_small";
+  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+  readonly minimum: number | bigint;
+  /** True if the allowable range includes the minimum */
+  readonly inclusive?: boolean;
+  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+  readonly exact?: boolean;
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+  readonly code: "invalid_format";
+  readonly format: $ZodStringFormats | (string & {});
+  readonly pattern?: string;
+  readonly input?: string;
+}
+interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+  readonly code: "not_multiple_of";
+  readonly divisor: number;
+  readonly input?: Input;
+}
+interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+  readonly code: "unrecognized_keys";
+  readonly keys: string[];
+  readonly input?: Record<string, unknown>;
+}
+interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: $ZodIssue[][];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly options?: Primitive[];
+  readonly inclusive?: true;
+}
+interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
+  readonly code: "invalid_union";
+  readonly errors: [];
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
+  readonly inclusive: false;
+  /** Indices of the options that matched */
+  readonly matches: number[];
+}
+type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
+interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_key";
+  readonly origin: "map" | "record";
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_element";
+  readonly origin: "map" | "set";
+  readonly key: unknown;
+  readonly issues: $ZodIssue[];
+  readonly input?: Input;
+}
+interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+  readonly code: "invalid_value";
+  readonly values: Primitive[];
+  readonly input?: Input;
+}
+interface $ZodIssueCustom extends $ZodIssueBase {
+  readonly code: "custom";
+  readonly params?: Record<string, any> | undefined;
+  readonly input?: unknown;
+}
+type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue$1<T> : never;
+type RawIssue$1<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The input data */
+  readonly input: unknown;
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
+  readonly schema?: $ZodType | undefined;
+  /** If `true`, Zod will continue executing checks/refinements after this issue. */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
+interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+  (issue: $ZodRawIssue<T>): {
+    message: string;
+  } | string | undefined | null;
+}
+interface $ZodError<T = unknown> extends Error {
+  type: T;
+  issues: $ZodIssue[];
+  _zod: {
+    output: T;
+    def: $ZodIssue[];
+  };
+  stack?: string;
+  name: string;
+}
+declare const $ZodError: $constructor<$ZodError>;
+type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in keyof T]?: U[]; };
+};
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? { [K in keyof T]?: $ZodFormattedError<T[K], U>; } : T extends any[] ? {
+  [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? Flatten<{ [K in keyof T]?: $ZodFormattedError<T[K], U>; }> : any;
+type $ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & Flatten<_ZodFormattedError<T, U>>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/core.d.cts
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+interface $constructorParams {
+  Parent?: typeof Class;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
+/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
+proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true; };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+    output: output<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output<T> & $brand<Brand>;
+  };
+});
+type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/core/api.d.cts
+type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined;
+  /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck // & { _issc: never },
+, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */
+  readonly inst?: $ZodType | $ZodCheck;
+  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+interface $ZodSuperRefineParams {
+  /** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>;
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/classic/parse.d.cts
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type ZodSafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: ZodError<T>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.1/node_modules/zod/v4/classic/schemas.d.cts
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
+  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+  validate(data: unknown, params?: ParseContext<$ZodIssue>): data is input<this>;
+  validateAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<boolean>;
+  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
+  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
+  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
+  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
+  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
+  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
+  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>, params?: $ZodSuperRefineParams): this;
+  overwrite(fn: (x: output<this>) => output<this>): this;
+  optional(): ZodOptional<this>;
+  exactOptional(): ZodExactOptional<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  default(def: NoUndefined<output<this>>): ZodDefault<this>;
+  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+  prefault(def: () => input<this>): ZodPrefault<this>;
+  prefault(def: input<this>): ZodPrefault<this>;
+  array(): ZodArray<this>;
+  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+  catch(def: output<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  readonly(): ZodReadonly<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace<GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace<GlobalMeta, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+declare const ZodType: $constructor<ZodType>;
+interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodArray: $constructor<ZodArray>;
+interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage/lib/types/backend.d.ts
+/**
+ * One registered backend. A backend owns exactly one medium and shares its
+ * lifecycle across all facets; facets are optional members — a backend that
+ * cannot serve a data kind simply omits it, and resolution fails loud instead.
+ */
+interface StorageBackend {
+  /** Key-value operations; absent when this backend cannot serve them. */
+  readonly kv?: KvFacet;
+  /**
+   * Drain in-flight writes across all open units and release the medium.
+   * Idempotent; concurrent and repeated calls resolve once teardown finishes.
+   * @returns resolution after the medium is released.
+   */
+  close(): Promise<void>;
+}
+/** The key-value data shape: whole-unit snapshots plus per-record durable writes. */
+interface KvFacet {
+  /**
+   * Open one unit, creating it when the medium holds no trace of it yet
+   * (materialization may defer to the first write, but {@link KvUnit.loadAll}
+   * must immediately serve the empty shape). A version already stamped on the
+   * medium that differs from `descriptor.version` rejects with
+   * `version-mismatch`; a medium that cannot be parsed as this unit rejects
+   * with `malformed-medium`. Opening the same unit name twice without closing
+   * is a caller bug and rejects.
+   * @param descriptor - Static identity and shape of the unit to open.
+   * @returns the opened unit.
+   */
+  open(descriptor: KvUnitDescriptor): Promise<KvUnit>;
+}
+/** Static identity and shape of one KV unit, projected from its owner's spec. */
+interface KvUnitDescriptor {
+  /** Unit name; must match {@link UNIT_NAME_RE}. Also the file-name / SQL-identifier segment. */
+  readonly name: string;
+  /** Unit format version; a non-negative integer stamped on the medium at first materialization. */
+  readonly version: number;
+  /** Table names; each must match {@link UNIT_NAME_RE}. */
+  readonly tables: readonly string[];
+  /** Whether this unit carries the global singleton slot. */
+  readonly hasGlobal: boolean;
+  /**
+   * Medium layout. `single` (the default) keeps the whole unit in one
+   * document; `per-record` keeps each record in its own document, so a unit
+   * whose records are large or sparse never rewrites the rest on one write,
+   * and an unaccepted version stamp discards only that record instead of
+   * rejecting the whole unit. Backends that only serve one layout accept the
+   * other's units as foreign documents.
+   */
+  readonly layout?: 'single' | 'per-record';
+  /**
+   * Older unit versions whose stored records are also readable under the
+   * declaring owner's current record schemas (the owner vouches for that —
+   * typically by declaring the fields old records lack as optional). Reads of
+   * a `per-record` unit accept documents stamped with any listed version, and
+   * the legacy whole-unit bootstrap accepts a legacy file stamped with one;
+   * writes always stamp {@link version}. `single`-layout reads stay
+   * exact-version.
+   */
+  readonly compatibleVersions?: readonly number[];
+}
+/**
+ * One opened unit. Values are opaque JSON to this layer: no schema, no
+ * events, no domain meaning. The unit does NOT serialize concurrent writes —
+ * write ordering is the caller's responsibility (the domain layer runs one
+ * write chain per unit); the unit only guarantees that each single call is
+ * atomic on the medium and durable once resolved (a crash after resolution
+ * followed by a re-open observes the write). Any call after {@link close}
+ * rejects with `closed`.
+ */
+interface KvUnit {
+  /**
+   * Read the full current snapshot.
+   * @returns every table's records keyed by table name, plus the global
+   * singleton (`null` when never written or not declared).
+   */
+  loadAll(): Promise<{
+    tables: Record<string, Record<string, unknown>>;
+    global: unknown;
+  }>;
+  /**
+   * Upsert one record durably. Overwrite semantics: an existing key is replaced.
+   * @param table - Declared table name.
+   * @param key - Record key. In the `per-record` layout a key becomes a path
+   * segment and must match `[a-zA-Z0-9_-]+` (an unsafe key rejects); in the
+   * `single` layout keys stay opaque.
+   * @param value - Opaque JSON-serializable record.
+   * @returns resolution after durability.
+   */
+  putRecord(table: string, key: string, value: unknown): Promise<void>;
+  /**
+   * Delete one record durably. Idempotent: a missing key is a no-op.
+   * @param table - Declared table name.
+   * @param key - Record key.
+   * @returns resolution after durability.
+   */
+  deleteRecord(table: string, key: string): Promise<void>;
+  /**
+   * Move one record's stored document out of the unit's readable set,
+   * preserving its bytes for inspection instead of deleting them. Backends
+   * whose medium has no per-record document to move (the `single` layout, a
+   * row store) omit this member, and the caller falls back to its
+   * reject-loud path. Absent after the move: a later {@link loadAll} reads
+   * the key as missing and a later {@link putRecord} recreates it fresh.
+   * @param table - Declared table name.
+   * @param key - Record key.
+   * @returns the medium location the document was moved to (diagnostics).
+   */
+  backupRecord?(table: string, key: string): Promise<string>;
+  /**
+   * Write the global singleton durably. Only valid when the descriptor
+   * declared `hasGlobal`.
+   * @param value - Opaque JSON-serializable value.
+   * @returns resolution after durability.
+   */
+  setGlobal(value: unknown): Promise<void>;
+  /**
+   * Drain this unit's in-flight writes and release it. Idempotent.
+   * @returns resolution after the unit is released.
+   */
+  close(): Promise<void>;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage/lib/types/registry.d.ts
+/**
+ * Mutable name → backend table. Multiple backends stay mounted side by side;
+ * which backend serves which consumer is the consumer's configuration
+ * (e.g. the domain layer's route table), never a hub-global choice.
+ */
+declare class BackendRegistry {
+  private readonly backends;
+  /**
+   * Register a named backend. Registration is an effect: the returned
+   * disposer removes the name. Disposal does NOT close the backend — the
+   * owning plugin closes it after unregistering.
+   * @param name - Backend name, e.g. `json` or `sqlite`.
+   * @param backend - The backend instance.
+   * @returns the disposer that unregisters the name.
+   */
+  register(name: string, backend: StorageBackend): () => void;
+  /**
+   * Resolve a backend by name.
+   * @param name - Registered backend name.
+   * @returns the backend.
+   */
+  get(name: string): StorageBackend;
+  /**
+   * Registered backend names, for diagnostics.
+   * @returns a snapshot array of names.
+   */
+  names(): string[];
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage/lib/types/index.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    storage: Storage;
+  }
+}
+/**
+ * Data forms mountable on the hub, keyed by form name. Form owners extend
+ * this map via declaration merging (the domain layer merges
+ * `domain: DomainFacility`) and mount the facility in their `apply`.
+ */
+interface StorageForms {}
+/**
+ * The storage hub service. Backends register under `backend`; data forms
+ * mount under their `StorageForms` key and are reached as `ctx.storage.<form>`.
+ */
+declare class Storage extends Service {
+  /** Named backend table; multiple backends stay mounted side by side. */
+  readonly backend: BackendRegistry;
+  private readonly forms;
+  constructor(ctx: Context);
+  /**
+   * Mount a data-form facility on the hub. Mounting is an effect: the
+   * returned disposer unmounts the form.
+   * @param form - Form key declared in {@link StorageForms}.
+   * @param facility - The facility instance to expose.
+   * @returns the disposer that unmounts the form.
+   */
+  mount<K extends keyof StorageForms>(form: K, facility: StorageForms[K]): () => void;
+  /**
+   * Resolve a mounted data form.
+   * @param form - Form key declared in {@link StorageForms}.
+   * @returns the mounted facility.
+   */
+  form<K extends keyof StorageForms>(form: K): StorageForms[K];
+  /** Domain data form; present once the domain layer plugin is loaded. */
+  get domain(): StorageForms extends {
+    domain: infer D;
+  } ? D : never;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage-domain/lib/types/spec.d.ts
+/** Global singleton declaration: schema plus the value used before the first write. */
+interface DomainGlobalSpec<G> {
+  /** Validates the stored global at the durable boundary. */
+  readonly schema: ZodType<G>;
+  /** Value served when the medium holds no global yet; not written until the first `set`. */
+  readonly initial: G;
+}
+/**
+ * One table declaration. `K` is a phantom key type (typically a branded
+ * string) carried for compile-time projection only; keys are plain strings on
+ * the medium.
+ */
+interface DomainTableSpec<K extends string = string, V = unknown> {
+  /** Validates every stored record at the durable boundary. */
+  readonly valueSchema: ZodType<V>;
+  /** Phantom carrier for the key type; never present at runtime. */
+  readonly __key?: K;
+}
+/** Static declaration of one domain: identity, version, and record layout. */
+interface DomainSpec {
+  /** Domain name; must match `UNIT_NAME_RE` (doubles as the backend unit name). */
+  readonly name: string;
+  /** Current domain format version; reads enforce it according to the selected layout. */
+  readonly version: number;
+  /**
+   * Medium layout for the backend unit: `single` (the default) stores the
+   * whole unit as one document; `per-record` stores each record as its own
+   * document, for units whose records are large, sparse, or individually
+   * disposable — the projection cache — and scopes version checks per record
+   * (an unaccepted record document is discarded, never migrated).
+   */
+  readonly layout?: 'single' | 'per-record';
+  /**
+   * Older domain versions whose stored records the current record schemas
+   * also accept (the declaring owner vouches for that, typically by
+   * declaring the fields older records lack as optional). `per-record` backends
+   * read documents stamped with a listed version instead of discarding them,
+   * and accept a legacy whole-unit file so stamped for the one-time
+   * bootstrap; writes always stamp {@link version}.
+   */
+  readonly compatibleVersions?: readonly number[];
+  /**
+   * What `open` does with a stored table record that fails its zod schema.
+   * Absent (the default), the whole open rejects with `invalid-record` —
+   * right for authoritative data. `'backup-and-skip'` is for domains whose
+   * records are disposable derived data: the backend moves the record's
+   * document aside (`KvUnit.backupRecord`), the failure is logged with
+   * its cause, and the open continues with the record absent. A backend
+   * without `backupRecord` (no per-record document to move) falls back
+   * to the rejecting default. The global slot always rejects.
+   */
+  readonly invalidRecords?: 'backup-and-skip';
+  /** Optional global singleton slot. */
+  readonly global?: DomainGlobalSpec<unknown>;
+  /** Table declarations keyed by table name; each name must match `UNIT_NAME_RE`. */
+  readonly tables: Record<string, DomainTableSpec>;
+}
+/** Key type of one declared table, recovered from its phantom carrier. */
+type TableKeyOf<S extends DomainSpec, N extends keyof S['tables']> = S['tables'][N] extends DomainTableSpec<infer K> ? K : never;
+/** Value type of one declared table. */
+type TableValueOf<S extends DomainSpec, N extends keyof S['tables']> = S['tables'][N] extends DomainTableSpec<string, infer V> ? V : never;
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage-domain/lib/types/domain.d.ts
+/** Handle on a domain's global singleton. */
+interface DomainGlobal<G> {
+  /**
+   * Current value, synchronously from the authoritative in-memory state.
+   * Before the first `set` this is the spec's `initial`.
+   * @returns the current global value.
+   */
+  get(): G;
+  /**
+   * Replace the value durably. Queued on the domain's write chain; the first
+   * `set` is what materializes the global on the medium.
+   * @param value - New value; must satisfy the spec's schema (not re-checked
+   * here — validation happens at the durable read boundary).
+   * @returns resolution after durability and event emission.
+   */
+  set(value: G): Promise<void>;
+}
+/**
+ * Handle on one declared table. Records are plain immutable data: returned
+ * values are the stored objects themselves (no defensive copies) and must not
+ * be mutated in place — replace via `put`/`update`.
+ */
+interface KvTable<K extends string, V> {
+  /**
+   * Read one record, synchronously from memory.
+   * @param key - Record key.
+   * @returns the record, or `undefined` when absent.
+   */
+  get(key: K): V | undefined;
+  /**
+   * Snapshot iterator over `[key, record]` pairs. A snapshot, not a live
+   * view: iteration stays stable while queued writes land.
+   * @returns the pair iterator.
+   */
+  entries(): IterableIterator<[K, V]>;
+  /**
+   * Snapshot iterator over keys.
+   * @returns the key iterator.
+   */
+  keys(): IterableIterator<K>;
+  /** Current record count. */
+  readonly size: number;
+  /**
+   * Insert or overwrite one record durably.
+   * @param key - Record key.
+   * @param value - The full new record (no partial merge).
+   * @returns resolution after durability and event emission.
+   */
+  put(key: K, value: V): Promise<void>;
+  /**
+   * Delete one record durably.
+   * @param key - Record key.
+   * @returns `true` when the record existed, `false` when it was already
+   * absent (no write and no event in that case).
+   */
+  delete(key: K): Promise<boolean>;
+  /**
+   * Atomic read-modify-write on the domain's write chain: `fn` sees the
+   * value current at its queue slot, so concurrent updates never interleave.
+   * @param key - Record key; a missing key rejects with `missing-key`.
+   * @param fn - Synchronous pure transform from current to next record.
+   * @returns the stored next record.
+   */
+  update(key: K, fn: (current: V) => V): Promise<V>;
+}
+/** Global handle of a spec: typed when declared, `never` (inaccessible) when not. */
+type DomainGlobalHandleOf<S extends DomainSpec> = S extends {
+  readonly global: DomainGlobalSpec<infer G>;
+} ? DomainGlobal<G> : never;
+/** One open domain, typed by its spec. */
+interface Domain<S extends DomainSpec> {
+  /** Domain name from the spec. */
+  readonly name: string;
+  /** Global singleton handle; a spec without `global` has no usable handle (`never`). */
+  readonly global: DomainGlobalHandleOf<S>;
+  /**
+   * Resolve one declared table handle. Handles are stable — repeated calls
+   * return the same instance.
+   * @param name - Declared table name.
+   * @returns the typed table handle.
+   */
+  table<N extends keyof S['tables'] & string>(name: N): KvTable<TableKeyOf<S, N>, TableValueOf<S, N>>;
+  /**
+   * Close this domain: reject new writes immediately, drain already-queued
+   * writes (their events still emit), release the backend unit, then free
+   * the domain name for a later open. Idempotent — repeated calls share one
+   * teardown. The consumer owns this call (typically as its own `ctx.effect`
+   * disposer); the facility closes any domain left open when it unmounts.
+   * @returns resolution after the unit is released.
+   */
+  close(): Promise<void>;
+}
+/**
+ * The single domain implementation behind the {@link Domain} interface. The
+ * facility constructs it from a validated `loadAll` snapshot and erases it to
+ * `Domain<S>`; nothing outside this package constructs one.
+ */
+declare class DomainImpl {
+  private readonly ctx;
+  private readonly unit;
+  private readonly onClosed;
+  /** Domain name from the spec. */
+  readonly name: string;
+  private readonly tables;
+  private globalValue;
+  private readonly globalHandle?;
+  /** Tail of the write chain; every link settles (rejections are observed by the caller's slice). */
+  private chain;
+  /** Set when close begins: new writes reject while already-queued writes drain. */
+  private disposing;
+  /** Set when close finishes (chain drained, unit closed): reads reject from here on. */
+  private closed;
+  private disposal?;
+  /**
+   * @param ctx - Context that carries `domain/changed` emissions.
+   * @param spec - The domain declaration.
+   * @param unit - The opened backend unit; this instance owns its lifecycle.
+   * @param records - Validated records from the unit's `loadAll`, one entry
+   * per declared table (empty maps included) — the facility builds it from
+   * the spec, so the entry set IS the table set.
+   * @param globalValue - Validated stored global, or the spec's `initial`
+   * when the medium held none; `undefined` when the spec declares no global.
+   * @param onClosed - Facility hook run once after teardown completes; frees
+   * the domain name for a later open.
+   */
+  constructor(ctx: Context, spec: DomainSpec, unit: KvUnit, records: Map<string, Map<string, unknown>>, globalValue: unknown, onClosed: () => void);
+  /** Global singleton handle; accessing it on a spec that declares no global is a caller bug and throws. */
+  get global(): DomainGlobal<unknown>;
+  /**
+   * Resolve one declared table handle; an undeclared name is a caller bug
+   * and throws.
+   * @param name - Declared table name.
+   * @returns the stable table handle.
+   */
+  table(name: string): KvTable<string, unknown>;
+  /**
+   * Close this domain: reject new writes immediately, drain already-queued
+   * writes (their events still emit), close the unit, then free the name via
+   * the facility hook. Idempotent — repeated calls share one teardown.
+   * @returns resolution after the unit is released.
+   */
+  close(): Promise<void>;
+  private runClose;
+  /**
+   * Dispatch one post-durability change notification, containing observer
+   * failures: the write is already committed (medium and memory both hold
+   * the new state), so a throwing listener must not retroactively reject it.
+   */
+  private emitChanged;
+  private enqueue;
+  private assertReadable;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage-domain/lib/types/events.d.ts
+/**
+ * Change-event vocabulary of the domain data form. Every durable write emits
+ * one event after the backend resolves durability, carrying the new snapshot
+ * and an operation discriminant — never the old value (a diffing consumer
+ * keeps its own previous snapshot). This is the event source for cross-process
+ * change push (RPC frames) in a later phase.
+ * @module @deepseek-ai/dsh-storage-domain/src/events
+ */
+/** Shared location fields of one durable domain change. */
+interface DomainChangedBase {
+  /** Owning domain name. */
+  readonly domain: string;
+  /** Table name; `''` for a global-singleton write. */
+  readonly table: string;
+  /** Record key; `''` for a global-singleton write. */
+  readonly key: string;
+}
+/** A record (or the global singleton) was inserted or overwritten. */
+interface DomainChangedPut extends DomainChangedBase {
+  readonly operation: 'put';
+  /** The new snapshot. */
+  readonly value: unknown;
+}
+/** A record was deleted; tombstones carry no value. */
+interface DomainChangedDeleted extends DomainChangedBase {
+  readonly operation: 'deleted';
+  readonly value?: never;
+}
+/** One durable domain change; a closed union — switch on `operation`. */
+type DomainChanged = DomainChangedPut | DomainChangedDeleted;
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    /**
+     * A domain record or the global singleton changed, emitted once per write
+     * strictly after the backend acknowledged durability. Events of one
+     * domain arrive in its write-chain order.
+     * @param change - domain, table (`''` for global), key (`''` for global),
+     * operation discriminant, and on `put` the new snapshot.
+     * @mode emit
+     */
+    'domain/changed'(change: DomainChanged): void;
+  }
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/storage/storage-domain/lib/types/index.d.ts
+declare module '@deepseek-ai/dsh-storage' {
+  interface StorageForms {
+    domain: DomainFacility;
+  }
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    storageDomain: DomainFacility;
+  }
+}
+/**
+ * Plugin config. Which backend serves which domain is decided here, not
+ * globally on the hub: `backend` is the default route and `routes` overrides
+ * it per domain name. A route naming an unregistered backend fails loud at
+ * `open` with `backend-not-found`.
+ */
+interface Config$2 {
+  /** Default backend name for every domain without an explicit route. Required: there is no universally correct medium. */
+  backend: string;
+  /** Per-domain overrides: domain name → backend name. */
+  routes?: Record<string, string>;
+}
+declare const Config$2: Schema<Config$2>;
+/**
+ * The mounted domain facility. Opens declared domains over routed backends;
+ * one facility instance owns the open-domain table and enforces single-open
+ * per domain name.
+ */
+declare class DomainFacility {
+  private readonly ctx;
+  private readonly config;
+  private readonly domains;
+  /** Names reserved by an in-flight or completed open, so concurrent opens of one name fail loud. */
+  private readonly reserved;
+  /**
+   * @param ctx - Context of the domain plugin; open-domain effects and change
+   * events attach here.
+   * @param config - Validated plugin config.
+   */
+  constructor(ctx: Context, config: Config$2);
+  /**
+   * Open one declared domain. Steps, each failing the whole call: reject a
+   * name that is already open (`already-open`); resolve the backend route
+   * (`backend-not-found` passes through from the hub); require its `kv` facet
+   * (`facet-unsupported`); open the unit projected from the spec (backend
+   * `version-mismatch`/`malformed-medium` pass through); load and validate
+   * every stored record against the spec's zod schemas (`invalid-record`
+   * with the offending table and key — unless the spec declares
+   * `invalidRecords: 'backup-and-skip'` and the unit can move documents aside, in
+   * which case the failing record is backed up, logged, and skipped);
+   * construct the domain.
+   *
+   * Lifecycle: the CALLER owns the returned handle and closes it via
+   * `Domain.close()` (typically as its own `ctx.effect` disposer) — the
+   * facility does not tie the domain to any consumer fiber. Domains still
+   * open when the facility unmounts are closed by the plugin disposer.
+   * @param spec - The domain declaration, typically from `defineDomain`.
+   * @returns the opened domain handle, typed by the spec.
+   */
+  open<S extends DomainSpec>(spec: S): Promise<Domain<S>>;
+  /**
+   * Look up an open domain by name, untyped. Diagnostic surface (the package
+   * invariant cross-checks change events against live domain state); typed
+   * consumers hold the handle returned by {@link open}.
+   * @param name - Domain name.
+   * @returns the open domain runtime, or `undefined` when not open.
+   */
+  get(name: string): DomainImpl | undefined;
+  /**
+   * Close every domain still open on this facility. The unmount path for
+   * consumers that never called `Domain.close()` themselves; closing is
+   * idempotent, so double-closing an already-closed domain is harmless.
+   * @returns resolution after every unit is released.
+   */
+  closeAll(): Promise<void>;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/session/session-projection-cache/lib/types/index.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    sessionProjectionCache: SessionProjectionCache;
+  }
+}
+/**
+ * Plugin config. Both throttle triggers are deployment choices with no
+ * universally correct value, so the composition states them explicitly
+ * (cordis.yml); the three mandatory write points (session creation,
+ * `turn/end`, and session disposal) are policy, not tunables, and always
+ * fire.
+ */
+interface Config$1 {
+  /** Committed events per session that force a durable checkpoint write between mandatory points. */
+  writeEveryEvents: number;
+  /** Longest time (milliseconds) a dirty checkpoint may stay unwritten between mandatory points. */
+  writeIntervalMs: number;
+}
+declare const Config$1: Schema<Config$1>;
+/**
+ * The persisted projection cache service. Opens the `session_projcache`
+ * domain at init, checkpoints live sessions on a throttled write-behind
+ * (count/interval triggers from {@link Config}) plus three mandatory points —
+ * session creation, `turn/end`, and session disposal (the live-to-cold
+ * moment) — and serves the
+ * cached rows for a session header. Every durable write is fail-soft:
+ * failures log a warning and the cache self-heals on the next write.
+ */
+declare class SessionProjectionCache extends Service {
+  config: Config$1;
+  static inject: string[];
+  static Config: Schema<Config$1>;
+  private table?;
+  private readonly dirty;
+  constructor(ctx: Context, config: Config$1);
+  /** Open the domain and install the write-behind listeners. */
+  protected [Service.init](): Promise<void>;
+  /**
+   * The stored record for one session, accepted only when its bound log
+   * identity matches `expected`. A session id names a slot, not a lifecycle:
+   * a recreated id or a persistence store swapped under a surviving cache
+   * must not let an old record seed state folded from an unrelated log.
+   * Synchronous from the domain's in-memory state — the same state every
+   * write mutated, so a read can never go around the write chain to the
+   * medium.
+   * @param id - the session whose record is read.
+   * @param expected - the log identity the caller holds (live or stored header).
+   * @returns the identity-matching record, or `undefined` (absent or unrelated).
+   */
+  private recordFor;
+  /**
+   * The zero-I/O listing read: whole values viewed straight from the stored
+   * rows (version-matching keys only), each cut carried with its watermark so
+   * a client value store can seed under its higher-seq-wins rule — as stale
+   * as the last durable checkpoint but never wrong, and never from an
+   * unrelated log (the caller's header is the identity witness). Fresher
+   * paths (the history tail baseline) supersede these values whenever a
+   * session is actually opened.
+   * @param meta - the listed session's header (identity witness; no log read).
+   * @param inheritedEventCount - exact inherited prefix length that completes
+   * the checkpoint identity.
+   * @param keys - optional projection keys required by the caller's audience.
+   * @returns the cut (`asOfSeq` = lowest served-row watermark), or
+   *   `undefined` when no usable row exists for this lifecycle.
+   */
+  cachedSnapshot(meta: SessionHeader$1, inheritedEventCount: SessionLogOffset, keys?: readonly Extract<keyof SessionProjectionMap, string>[]): ProjectionSnapshot | undefined;
+  /**
+   * Read only a predecessor checkpoint's title as a zero-I/O listing hint.
+   *
+   * The authoritative Session header supplies the lifecycle identity. A cache
+   * checkpoint can lag that log but cannot lead it because writes flush the
+   * log first, so a matching predecessor title is a genuine (possibly stale)
+   * fact from this Session. The registry still requires the current title
+   * projection's row version and schema. No other predecessor projection is
+   * exposed: format normalization can change their current meaning, and the
+   * strict {@link cachedSnapshot} / hydration paths continue to reject them.
+   * @param meta - authoritative listed Session header.
+   * @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
+   * @returns a title-only checkpoint view with `asOfSeq: -1`, or `undefined`
+   *   when the record is current, newer, unrelated, missing, or incompatible
+   *   with the title unit. The sentinel avoids reusing a sequence that a
+   *   cardinality-changing Session migration may have remapped.
+   */
+  cachedPredecessorTitle(meta: SessionHeader$1, inheritedEventCount: SessionLogOffset): ProjectionSnapshot | undefined;
+  /** View selected wire rows and bind them to their lowest served watermark. */
+  private viewRecord;
+  /**
+   * Hydrate projection cells for an already-prepared Session without another
+   * persistence read. The cache seeds matching rows; the supplied exact log
+   * advances every unit to the observation cut. No checkpoint is written
+   * because the logical observation may contain recovery events not yet durable.
+   * @param session - exact unpublished Session retained by persistence.
+   * @param events - exact logical event prefix represented by the observation.
+   * @returns all projection values at the event cut.
+   */
+  hydratePrepared(session: Session$1, events: readonly SessionEvent$1[]): ProjectionSnapshot;
+  /**
+   * Durably checkpoint one live session NOW (all mandatory points call
+   * this; tests and carriers may too). The registry cut is snapshotted at
+   * this boundary (states are live references), then the session's record is
+   * replaced on the domain's write chain. NOT fail-soft — callers on the
+   * fail-soft paths contain it.
+   * @param session - the live session to checkpoint.
+   * @returns resolution after durability and event emission.
+   */
+  write(session: Session$1): Promise<void>;
+  /**
+   * Cold-read one session's projections from its complete log. Each unit is
+   * seeded from the identity-checked cached rows — the registry skips `apply`
+   * for the already-folded prefix (events at or below the row's `seq`) — and
+   * the refreshed checkpoint is written back (fail-soft, fire-and-forget), so
+   * the first cold read creates the cache row and later ones seed from it.
+   * The caller supplies the complete log in seq order: this service never
+   * consults the persistence layer.
+   * @param meta - the stored session header (identity witness).
+   * @param inheritedEventCount - exact inherited prefix length for projection initialization and identity.
+   * @param events - the session's complete log, in seq order.
+   * @returns the projection cut at the log end.
+   */
+  coldSnapshot(meta: SessionHeader$1, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent$1[]): ProjectionSnapshot;
+  private installWritePath;
+  /**
+   * One fail-soft durable checkpoint. Every caller has work by construction:
+   * the throttle triggers only fire dirty (markClean clears the timer with
+   * the counter) and the mandatory points write unconditionally.
+   */
+  private flushSoft;
+  /** Reset one session's dirty bookkeeping (its checkpoint is being written). */
+  private markClean;
+  /** Replace one session's stored record with its log identity and a detached snapshot of `rows`. */
+  private put;
+  private requireTable;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/util/brand/lib/types/index.d.ts
+/**
+ * Duplicate-install-safe nominal primitive helpers.
+ *
+ * A brand makes structurally identical strings or numbers non-interchangeable
+ * at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
+ * expected, and an event sequence cannot be passed as a log offset. Comparison,
+ * logging, and serialization retain the underlying primitive behavior.
+ *
+ * This package owns no concrete domain value and keeps no runtime identity or mutable
+ * state, so independently installed copies produce interchangeable values.
+ *
+ * @module @deepseek-ai/dsh-brand
+ */
+declare const BRAND: unique symbol;
+/** A string carrying a compile-time-only brand `B`. */
+type Branded<B extends string> = string & {
+  readonly [BRAND]: B;
+};
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/workspace/workspace/lib/types/types.d.ts
+/**
+ * Identifies one workspace record. A generated uuid, never the path: path
+ * normalization rewrites paths, and a reference anchor must stay stable.
+ */
+type WorkspaceId$1 = Branded<'WorkspaceId'>;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface RemoteErrorDetailsMap {
+    /** No registration carries that Workspace identity. */
+    'workspace/not-found': {
+      readonly workspaceId: WorkspaceId$1;
+    };
+  }
+}
+/**
+ * One workspace: a stable id over an existing directory, a display title, and
+ * an ordered candidate account of sessions. Membership requires both an id in
+ * that account and a session header whose canonical cwd equals the workspace
+ * path. Consumers only see this interface; the implementation stays private.
+ */
+interface Workspace {
+  /** Stable record id (generated uuid). */
+  readonly id: WorkspaceId$1;
+  /**
+   * Canonical directory path: the `fs.realpath` of the path given at create
+   * time (trailing slashes, `..`, and symlinks all resolved). Never rewritten
+   * afterwards, even when the directory disappears (see {@link status}).
+   */
+  readonly path: string;
+  /** Display title. Defaults to the final path segment, or a filesystem root's own spelling; duplicates are allowed. */
+  readonly title: string;
+  /** ISO-8601 creation instant, stamped at create and never rewritten. */
+  readonly createdAt: string;
+  /** ISO-8601 instant of the last durable mutation (create counts as one). */
+  readonly updatedAt: string;
+  /**
+   * Header-validated sessions in manually owned order: a new session is
+   * prepended at attach, explicit reordering goes through
+   * `insertSessionBefore`, and activity never reorders. The durable candidate
+   * account is filtered synchronously: missing headers, invalid cwd values,
+   * and canonical cwd mismatches are never returned. A subsequent workspace
+   * mutation prunes those filtered candidates durably.
+   */
+  readonly sessionIds: readonly SessionId$1[];
+  /**
+   * Replace the display title durably.
+   * @param title - New title; any string, duplicates across workspaces allowed.
+   * @returns resolution after durability.
+   */
+  setTitle(title: string): Promise<void>;
+  /**
+   * Prepend a session to this workspace's candidate account. An already
+   * accounted id resolves without writing, aside from the durable
+   * filtered-candidate prune every accepted mutation performs. A new id's
+   * live or persisted
+   * header cwd must resolve to an existing directory equal to {@link path};
+   * unknown ids, missing or invalid cwd values, and mismatches reject without
+   * writing.
+   * @param sessionId - The session to record.
+   * @returns resolution after durability.
+   */
+  attachSession(sessionId: SessionId$1): Promise<void>;
+  /**
+   * Move an accounted session within the manual order, DOM-insertBefore-like:
+   * with an anchor the session lands before it, without one it appends to the
+   * end. Only the moved id changes position. A session or anchor absent from
+   * the account rejects without writing; a move to the current position
+   * resolves without writing, aside from the durable filtered-candidate
+   * prune every accepted mutation performs; decided on the domain write
+   * chain.
+   * @param sessionId - The accounted session to move.
+   * @param beforeSessionId - Accounted anchor to insert before; omitted appends.
+   * @returns resolution after durability.
+   */
+  insertSessionBefore(sessionId: SessionId$1, beforeSessionId?: SessionId$1): Promise<void>;
+  /**
+   * Remove a session from this workspace's account. Idempotent: an id not on
+   * the account resolves without writing, aside from the durable
+   * filtered-candidate prune every accepted mutation performs; decided on
+   * the domain write chain like attach. Never touches the session's own stored log.
+   * @param sessionId - The session to remove.
+   * @returns resolution after durability.
+   */
+  detachSession(sessionId: SessionId$1): Promise<void>;
+  /**
+   * Live directory check, uncached: whether {@link path} currently exists and
+   * is a directory. A missing directory never mutates the record — the
+   * directory may only be temporarily moved.
+   * @returns `'ok'` when the directory exists, `'missing-dir'` otherwise.
+   */
+  status(): Promise<'ok' | 'missing-dir'>;
+}
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/workspace/workspace/lib/types/index.d.ts
+/** Identifies one workspace record (see `src/types.ts` for the brand rationale). */
+type WorkspaceId = WorkspaceId$1;
+/**
+ * Brand a string as a {@link WorkspaceId}.
+ * @param id - Raw workspace id string.
+ * @returns the same string, branded at compile time.
+ */
+declare function WorkspaceId(id: string): WorkspaceId;
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    workspaceRegistry: WorkspaceRegistry;
+  }
+}
+/**
+ * Durable workspace registry. Startup waits for `sessionPersistence`, builds
+ * one canonical-cwd header index, and completes the one-time history
+ * bootstrap before the service becomes active. The persistence dependency is
+ * mandatory so an unavailable peer can never be mistaken for an empty
+ * history and commit the initialized marker.
+ */
+declare class WorkspaceRegistry extends Service {
+  static inject: string[];
+  private table?;
+  private global?;
+  private state?;
+  private readonly entities;
+  private readonly headers;
+  private readonly sessionPaths;
+  private readonly invalidSessionPaths;
+  private operationTail;
+  private readonly host;
+  constructor(ctx: Context);
+  /** Open the domain, finish bootstrap when required, and rebuild the ordered cache. */
+  protected [Service.init](): Promise<void>;
+  /**
+   * Create or reuse a workspace for an existing directory. The fully qualified
+   * path is canonicalized through `fs.realpath`; a relative, nonexistent, or
+   * non-directory path rejects. Repeated calls for the same canonical path
+   * return the existing entity without changing its title.
+   * A newly created workspace is prepended to the durable registry order.
+   * Different canonical paths may share a display title.
+   * @param path - Existing directory to own, in a fully qualified path spelling.
+   * @param title - Display title used only when a new record is created.
+   * @returns the existing or newly durable workspace.
+   */
+  create(path: string, title?: string): Promise<Workspace>;
+  /**
+   * Look up a workspace by id.
+   * @param id - Workspace id.
+   * @returns the workspace, or `undefined` when unknown.
+   */
+  get(id: WorkspaceId): Workspace | undefined;
+  /**
+   * Synchronous workspace projection in durable registry order. Every
+   * entity's `sessionIds` getter is already filtered by the startup/live
+   * canonical-cwd header index; this method performs no persistence reads.
+   * @returns a fresh ordered array of workspace entities.
+   */
+  list(): Workspace[];
+  /**
+   * Delete one workspace registration while retaining its directory and every
+   * session log. The durable order is updated before the table deletion; a
+   * failed table write restores the prior order and keeps the entity
+   * published. Unknown ids are an idempotent no-op for domain callers.
+   * @param id - Workspace registration to remove.
+   * @returns `true` when a record was deleted, `false` when it was unknown.
+   */
+  delete(id: WorkspaceId): Promise<boolean>;
+  /**
+   * Move one workspace within the durable display order, DOM-insertBefore-like.
+   * With an anchor it lands before that workspace; without one it appends.
+   * @param id - Workspace to move.
+   * @param beforeId - Workspace anchor; omitted appends.
+   * @returns the complete committed workspace order.
+   */
+  insertBefore(id: WorkspaceId, beforeId?: WorkspaceId): Promise<readonly WorkspaceId[]>;
+  /**
+   * The registry-global archive set: sessions hidden from every grouping
+   * surface. Archiving never touches workspace accounting — an archived
+   * session keeps its `sessionIds` slot so unarchiving restores its position.
+   * @returns the archived session ids in archive order.
+   */
+  get archivedSessionIds(): readonly SessionId[];
+  /**
+   * Archive one session durably. The session must exist (live or in session
+   * persistence); its workspace accounting — or lack of one — is irrelevant.
+   * An already archived id resolves without writing.
+   * @param sessionId - The session to archive.
+   * @returns resolution after durability.
+   */
+  archiveSession(sessionId: SessionId): Promise<void>;
+  /**
+   * Whether a session is live, header-indexed, or present in a fresh
+   * persistence listing. Only a definite miss returns false — a failing
+   * `sessionPersistence.list()` propagates so storage faults never
+   * masquerade as an unknown session.
+   */
+  private sessionKnown;
+  /**
+   * Resolve by canonical directory path without creating or mutating a
+   * workspace. A missing path rejects during `realpath`; an existing unowned
+   * directory returns `undefined`.
+   * @param path - Existing directory path in a fully qualified spelling.
+   * @returns the workspace owning the canonical path, when one exists.
+   */
+  resolveByPath(path: string): Promise<Workspace | undefined>;
+  private createCanonical;
+  private deleteKnown;
+  /**
+   * Complete the one mutation explicitly named by durable state. Unexplained
+   * order/table divergence still reaches {@link validateStoredState} and
+   * fails loud; this path never guesses which operation created a row from its shape alone.
+   */
+  private recoverPendingMutation;
+  private bootstrap;
+  private validateStoredState;
+  private rebuildEntities;
+  private replaceHeaderIndex;
+  private indexHeaders;
+  private indexHeader;
+  /** Every stored session's header, projected from the persistence snapshot listing. */
+  private listStoredHeaders;
+  private indexLiveSessions;
+  private reportFilteredCandidates;
+  private readSessionHeader;
+  private requireTable;
+  private requireState;
+  private setState;
+  private enqueueOperation;
+}
+//#endregion
+//#region ../session-rdb/src/import.d.ts
+declare function parseJsonlArtifact(content: string): SessionStorageMetadata & {
+  events: SessionEvent$1[];
+};
+//#endregion
+//#region ../../vendor/deepseek-harness/packages/settings/settings/lib/types/redact.d.ts
+/** One schema-declared secret position inside a redacted value. */
+interface RedactedSecret {
+  /** Path from the section root to the removed field (concrete dict keys and array indexes included). */
+  path: string[];
+  /** Whether the field held a value before redaction. */
+  set: boolean;
+}
 //#endregion
 //#region ../../vendor/deepseek-harness/packages/settings/settings/lib/types/types.d.ts
 /** Nominal id of one registered settings namespace. */