better-dsh 0.2.5-a → 0.2.5-c

package/lib/chunk-DQxbwPpZ.js

@@ -0,0 +1,30 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __toESM as r, __commonJS as t };

package/lib/compaction/index.d.ts

@@ -1,5 +1,5 @@
+import { t as Schema } from "../index-DZQNwO7f.js";
 import { Context, Volatile } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
 
 //#region src/compaction/config.d.ts
 
@@ -30,7 +30,7 @@ declare const inject: string[];
  * `retainTokens` is composition-only (see {@link DEFAULT_RETAIN_TOKENS}) and
  * stays non-volatile — form writes never touch it, a patch file still can.
  */
-declare const Config: z<CompactionTuningConfig>;
+declare const Config: Schema<CompactionTuningConfig>;
 /**
  * The row config as cordis hands it over post-resolution: the volatile
  * threshold arrives as a live reference, not a plain number.
@@ -50,7 +50,7 @@ declare function apply(ctx: Context, config: ResolvedCompactionTuningConfig | un
 declare const _default: {
   name: string;
   inject: string[];
-  Config: z<CompactionTuningConfig>;
+  Config: Schema<CompactionTuningConfig>;
   apply: typeof apply;
 };
 //#endregion

package/lib/compaction/index.js

@@ -1,5 +1,5 @@
+import { t as Schema } from "../lib-C8_jXvwA.js";
 import { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
 
 //#region src/compaction/config.ts
 /** Upstream `compaction-basic`'s own default: condense at 80% of the window. */
@@ -42,9 +42,9 @@ const inject = [];
 * `retainTokens` is composition-only (see {@link DEFAULT_RETAIN_TOKENS}) and
 * stays non-volatile — form writes never touch it, a patch file still can.
 */
-const Config = z.object({
-	thresholdRatio: z.number().step(.01).min(THRESHOLD_MIN_RATIO).max(THRESHOLD_MAX_RATIO).default(DEFAULT_THRESHOLD_RATIO).volatile(),
-	retainTokens: z.number().step(1).min(0).default(DEFAULT_RETAIN_TOKENS)
+const Config = Schema.object({
+	thresholdRatio: Schema.number().step(.01).min(THRESHOLD_MIN_RATIO).max(THRESHOLD_MAX_RATIO).default(DEFAULT_THRESHOLD_RATIO).volatile(),
+	retainTokens: Schema.number().step(1).min(0).default(DEFAULT_RETAIN_TOKENS)
 });
 /**
 * Keep the live compaction engine on the user's threshold preference.

package/lib/failover/index.d.ts

@@ -1,5 +1,5 @@
+import { t as Schema } from "../index-DZQNwO7f.js";
 import { Context, Volatile } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
 
 //#region src/failover/config.d.ts
 
@@ -27,7 +27,7 @@ declare const inject: string[];
  * profile-layer patch override on THIS row's entry, the runtime rewrites the
  * resolved refs in place, and every request re-reads them without a reload.
  */
-declare const Config: z<FailoverConfig>;
+declare const Config: Schema<FailoverConfig>;
 /**
  * The row config as cordis hands it over post-resolution: volatile fields are
  * live references, not plain strings.
@@ -52,7 +52,7 @@ declare function apply(ctx: Context, config: ResolvedFailoverConfig | undefined)
 declare const _default: {
   name: string;
   inject: string[];
-  Config: z<FailoverConfig>;
+  Config: Schema<FailoverConfig>;
   apply: typeof apply;
 };
 //#endregion

package/lib/failover/index.js

@@ -1,6 +1,6 @@
+import { t as Schema } from "../lib-C8_jXvwA.js";
 import { Context } from "@deepseek-ai/cordis";
 import { randomUUID } from "node:crypto";
-import z from "@deepseek-ai/schemastery";
 import { RetryId } from "@deepseek-ai/dsh-llm-retry";
 
 //#region src/failover/config.ts
@@ -48,9 +48,9 @@ const inject = [];
 * profile-layer patch override on THIS row's entry, the runtime rewrites the
 * resolved refs in place, and every request re-reads them without a reload.
 */
-const Config = z.object({
-	fallback1: z.string().default("").volatile(),
-	fallback2: z.string().default("").volatile()
+const Config = Schema.object({
+	fallback1: Schema.string().default("").volatile(),
+	fallback2: Schema.string().default("").volatile()
 });
 /** Read one field that may be a plain value (tests, defaults) or a live ref (composed row). */
 function readSlot(slot) {

package/lib/fs-aware/sandbox-plugin.js

@@ -1,4 +1,4 @@
-import { f as UrlSchemesError, t as buildFsLayerResolver } from "../wrap-Bzdimp4p.js";
+import { f as UrlSchemesError, t as buildFsLayerResolver } from "../wrap-0VA0uFx8.js";
 import { Context } from "@deepseek-ai/cordis";
 import { dirname, sep } from "node:path";
 import { stat } from "node:fs/promises";
@@ -18,19 +18,19 @@ function isMissing(error) {
 	const code = error.code;
 	return MISSING_CODES.has(code);
 }
-function comparablePath(path, caseSensitive) {
-	return caseSensitive ? path : path.toLowerCase();
+function comparablePath(path$1, caseSensitive) {
+	return caseSensitive ? path$1 : path$1.toLowerCase();
 }
-function isLexicallyUnder(path, root, caseSensitive) {
-	const comparableTarget = comparablePath(path, caseSensitive);
+function isLexicallyUnder(path$1, root, caseSensitive) {
+	const comparableTarget = comparablePath(path$1, caseSensitive);
 	const comparableRoot = comparablePath(root, caseSensitive);
 	if (comparableTarget === comparableRoot) return true;
 	const prefix = comparableRoot.endsWith(sep) ? comparableRoot : comparableRoot + sep;
 	return comparableTarget.startsWith(prefix);
 }
-async function statIfPresent(path) {
+async function statIfPresent(path$1) {
 	try {
-		return await stat(path, { bigint: true });
+		return await stat(path$1, { bigint: true });
 	} catch (error) {
 		/* v8 ignore else -- a non-missing stat failure requires a host permission or I/O fault after resolve reached this ancestor. */
 		if (isMissing(error)) return void 0;
@@ -53,11 +53,11 @@ function sameIdentity(left, right) {
 *   to the host filesystem convention used by supported platforms.
 * @returns whether the target is the root or a descendant of it.
 */
-async function isPathUnder(path, root, caseSensitive = process.platform !== "win32") {
-	if (isLexicallyUnder(path, root, caseSensitive)) return true;
+async function isPathUnder(path$1, root, caseSensitive = process.platform !== "win32") {
+	if (isLexicallyUnder(path$1, root, caseSensitive)) return true;
 	const rootInfo = await statIfPresent(root);
 	if (!rootInfo) return false;
-	let ancestor = path;
+	let ancestor = path$1;
 	while (true) {
 		const ancestorInfo = await statIfPresent(ancestor);
 		if (ancestorInfo && sameIdentity(ancestorInfo, rootInfo)) return true;
@@ -170,12 +170,12 @@ var SandboxedFileSystem = class extends LocalFileSystem {
 //#endregion
 //#region src/fs-aware/sandbox-plugin.ts
 /** Scheme prefix test — mirrors the resolver's own grammar. */
-function isSchemePath(path) {
-	return /^[a-z][a-z0-9]*:\/\//.test(path);
+function isSchemePath(path$1) {
+	return /^[a-z][a-z0-9]*:\/\//.test(path$1);
 }
 /** Session-layer schemes are excluded from FS-layer resolution (design D2). */
-function isSessionLayerScheme(path) {
-	return path.startsWith("ctx://") || path.startsWith("agent://") || path.startsWith("skill://");
+function isSessionLayerScheme(path$1) {
+	return path$1.startsWith("ctx://") || path$1.startsWith("agent://") || path$1.startsWith("skill://");
 }
 function sessionLayerError(url) {
 	if (url.startsWith("skill://")) return new UrlSchemesError("CTX_SESSION_LAYER", `${url}: session-layer scheme — skill discovery (which roots load, scan depth, layered scope merge) is the host skill provider's business logic and resolves only against a calling agent, which the filesystem layer does not have. Load skills with the native \`skill\` tool; grep/glob with path=skill://… keep working through the tool layer`);
@@ -213,13 +213,13 @@ var FsAwareSandboxFileSystem = class extends Base {
 			rawUrl: url
 		};
 	}
-	async resolve(path, opts) {
-		if (!this.schemeResolution || !isSchemePath(path)) return super.resolve(path, opts);
-		if (isSessionLayerScheme(path)) throw sessionLayerError(path);
-		await this.resolver.resolve(this.envFor(path), path);
+	async resolve(path$1, opts) {
+		if (!this.schemeResolution || !isSchemePath(path$1)) return super.resolve(path$1, opts);
+		if (isSessionLayerScheme(path$1)) throw sessionLayerError(path$1);
+		await this.resolver.resolve(this.envFor(path$1), path$1);
 		return {
-			targetKey: path,
-			displayPath: path
+			targetKey: path$1,
+			displayPath: path$1
 		};
 	}
 	async stat(target, signal) {

package/lib/index-DZQNwO7f.d.ts

@@ -0,0 +1,208 @@
+import { Binary, Dict, Volatile } from "@deepseek-ai/cosmokit";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region third_party/schemastery/lib/types/index.d.ts
+declare const kSchema: unique symbol;
+declare global {
+  namespace Schemastery {
+    /** Convert primitive constructors, constants, and existing schemas into a schema type. */
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema<any, any, SchemaMode> ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, infer _T, infer _M> ? S : never;
+    type Inverse<X> = X extends Schema<infer _S, infer T, infer M> ? (arg: SchemaOutput<T, M>) => void : never;
+    /** Input type accepted by a schema-like value. */
+    type TypeS<X> = TypeS1<From<X>>;
+    /** Output type returned by a schema-like value after validation. */
+    type TypeT<X> = ReturnType<From<X>>;
+    /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
+    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    /** Input type accepted by one schema in an intersection. */
+    type IntersectS<X> = From<X> extends Schema<infer S, infer _T, infer _M> ? S : never;
+    /** Output type returned by one schema in an intersection. */
+    type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
+    type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
+    type TupleT<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeT<L>?, ...TupleT<R>] : any[];
+    type ObjectS<X extends Dict> = { [K in keyof X]?: TypeS<X[K]> | null } & Dict;
+    type ObjectT<X extends Dict> = { [K in keyof X]: TypeT<X[K]> } & Dict;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    /** Static constructor and factory methods exposed by the default `Schema` export. */
+    interface Static {
+      <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      prototype: Schema;
+      /** Validate a value against a schema node and return `[output, adaptedInput?]`. */
+      resolve: Resolve;
+      /** Infer a schema from a primitive value, constructor, or existing schema. */
+      from<X = any>(source?: X): From<X>;
+      /** Register a resolver for a custom schema `type`. */
+      extend(type: string, resolve: Resolve): void;
+      /** Accept any value without validation. */
+      any<T = any>(): Schema<T>;
+      /** Accept only nullable input. */
+      never(): Schema<never>;
+      /** Accept exactly one constant value. */
+      const<const T>(value: T): Schema<T>;
+      /** Accept strings, with optional metadata constraints added by instance methods. */
+      string(): Schema<string>;
+      /** Accept numbers, with optional range and step constraints. */
+      number(): Schema<number>;
+      /** Accept non-negative integer numbers. */
+      natural(): Schema<number>;
+      /** Accept a number between 0 and 1 and mark it as a slider. */
+      percent(): Schema<number>;
+      /** Accept booleans. */
+      boolean(): Schema<boolean>;
+      /** Accept `Date` instances or parse datetime strings into `Date` objects. */
+      date(): Schema<string | Date, Date>;
+      /** Accept `RegExp` instances or parse strings into regular expressions. */
+      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      /** Accept binary sources and normalize them to `ArrayBufferLike`. */
+      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      /** Accept a numeric bitset or string keys and normalize to a number. */
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      /** Accept functions. */
+      function(): Schema<Function, (...args: any[]) => any>;
+      /** Accept instances of a constructor or objects whose constructor name matches. */
+      is(constructor: string): Schema;
+      is<T>(constructor: Constructor<T>): Schema<T>;
+      /** Accept arrays whose elements match `inner`. */
+      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      /** Accept plain objects with values matching `inner` and optional key schema. */
+      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      /** Accept tuple arrays where each index matches the corresponding schema. */
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      /** Accept plain objects; infer fields from the dictionary, not the enclosing schema's output type. */
+      object<X extends Dict>(dict: X): Schema<ObjectS<NoInfer<X>>, ObjectT<NoInfer<X>>>;
+      /** Accept values matching at least one schema in `list`. */
+      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      /** Accept values matching every schema in `list`, merging object outputs. */
+      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      /** Validate with `inner`, then convert the result with `callback`. */
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      /** Defer construction of a recursive schema until validation or serialization. */
+      lazy<X extends Schema<any, any, SchemaMode>>(callback: () => X): X;
+      ValidationError: typeof ValidationError;
+    }
+    /** Runtime validation options shared by all schema calls. */
+    interface Options {
+      /** Remove invalid object properties instead of throwing when possible. */
+      autofix?: boolean;
+      /** Skip validation for selected values and schema nodes. */
+      ignore?(data: any, schema: Schema): boolean;
+      /** Path used to format nested validation errors. */
+      path?: (keyof any)[];
+    }
+    /** UI and validation metadata attached by schema builder methods. */
+    interface Meta<T = any> {
+      default?: T extends {} ? Partial<T> : T;
+      required?: boolean;
+      /** Parse this node as a stable config reference; its type and UI metadata remain unchanged. */
+      volatile?: boolean;
+      disabled?: boolean;
+      collapse?: boolean;
+      badges?: {
+        text: string;
+        type: string;
+      }[];
+      hidden?: boolean;
+      loose?: boolean;
+      role?: string;
+      extra?: any;
+      link?: string;
+      description?: string | Dict<string>;
+      comment?: string;
+      pattern?: {
+        source: string;
+        flags?: string;
+      };
+      max?: number;
+      min?: number;
+      step?: number;
+    }
+  }
+  /** Callable schema instance that validates input and returns normalized output. */
+  interface Schemastery<S = any, T = S, Mode extends SchemaMode = 'plain'> {
+    (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
+    new (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
+    [kSchema]: true;
+    uid: number;
+    meta: Schemastery.Meta<T>;
+    type: string;
+    sKey?: Schema;
+    inner?: Schema;
+    list?: Schema[];
+    dict?: Dict<Schema>;
+    bits?: Dict<number>;
+    callback?: Function;
+    constructor?: string | Function;
+    builder?: Function;
+    value?: T;
+    refs?: Dict<Schema>;
+    preserve?: boolean;
+    '~standard': StandardSchemaV1.Props;
+    /** Format this schema as a compact TypeScript-like type string. */
+    toString(inline?: boolean): string;
+    /** Serialize this schema, preserving shared and recursive references. */
+    toJSON(): Schema<S, T, Mode>;
+    /** Mark nullable input as invalid unless a default supplies a fallback. */
+    required<R extends boolean = true>(value?: R): Schema<S, T, SetRequired<Mode, R>>;
+    /**
+     * Parse this config field as a stable reference containing immutable data.
+     * @returns a schema whose output supports get(), including when the field is absent.
+     */
+    volatile(): Schema<NoInfer<S>, NoInfer<T>, Mode extends 'defined' | 'volatile-defined' ? 'volatile-defined' : 'volatile'>;
+    /** Hide this schema node from UI renderers. */
+    hidden(value?: boolean): Schema<S, T, Mode>;
+    /** Return the default value instead of throwing when validation fails. */
+    loose(value?: boolean): Schema<S, T, Mode>;
+    /** Attach a renderer role and optional role-specific metadata. */
+    role(text: string, extra?: any): Schema<S, T, Mode>;
+    /** Attach an external documentation link. */
+    link(link: string): Schema<S, T, Mode>;
+    /** Set the fallback value used for nullable input. */
+    default(value: T | NoInfer<Partial<S>>): Schema<S, T, SetRequired<Mode, true>>;
+    /** Attach an auxiliary comment for documentation or form UIs. */
+    comment(text: string): Schema<S, T, Mode>;
+    /** Attach a localized or plain description for documentation or form UIs. */
+    description(text: string): Schema<S, T, Mode>;
+    /** Mark this schema node as disabled for form UIs. */
+    disabled(value?: boolean): Schema<S, T, Mode>;
+    /** Request collapsed rendering for nested form UIs. */
+    collapse(value?: boolean): Schema<S, T, Mode>;
+    /** Add a deprecated badge to this schema node. */
+    deprecated(): Schema<S, T, Mode>;
+    /** Add an experimental badge to this schema node. */
+    experimental(): Schema<S, T, Mode>;
+    /** Require strings to match a regular expression. */
+    pattern(regexp: RegExp): Schema<S, T, Mode>;
+    /** Set an inclusive maximum for numbers or collection lengths. */
+    max(value: number): Schema<S, T, Mode>;
+    /** Set an inclusive minimum for numbers or collection lengths. */
+    min(value: number): Schema<S, T, Mode>;
+    /** Set the numeric increment constraint. */
+    step(value: number): Schema<S, T, Mode>;
+    /** Add or replace an object property schema. */
+    set(key: string, value: Schema): Schema<S, T, Mode>;
+    /** Append a tuple, union, or intersection member schema. */
+    push(value: Schema): Schema<S, T, Mode>;
+    /** Remove values equal to schema defaults from normalized output. */
+    simplify(value?: any): any;
+    /** Return a schema clone with descriptions merged from locale messages. */
+    i18n(messages: Dict): Schema<S, T, Mode>;
+    /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T, Mode>;
+  }
+}
+declare class ValidationError extends TypeError {
+  options: Schemastery.Options;
+  name: string;
+  constructor(message: string, options: Schemastery.Options);
+  static is(error: any): error is ValidationError;
+}
+type SchemaMode = 'plain' | 'defined' | 'volatile' | 'volatile-defined';
+type SchemaOutput<T, M$1 extends SchemaMode> = M$1 extends 'volatile' ? Volatile<T | undefined> : M$1 extends 'volatile-defined' ? Volatile<T> : T;
+type SetRequired<M$1 extends SchemaMode, R extends boolean> = M$1 extends 'volatile' | 'volatile-defined' ? R extends true ? 'volatile-defined' : 'volatile' : R extends true ? 'defined' : 'plain';
+type Schema<S = any, T = S, Mode extends SchemaMode = 'plain'> = Schemastery<S, T, Mode>;
+declare const Schema: Schemastery.Static;
+//#endregion
+export { Schema as t };