@banbolee/dsh-fish-shell 0.6.0 → 0.8.0

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,91 @@
+# Third-party notices — `@banbolee/dsh-fish-shell`
+
+This package distributes third-party code inside its tarball. The runtime
+dependency listed under `bundledDependencies` in `package.json` — and its
+transitive dependencies — are packed as real files under
+`package/node_modules/**` by the release chain
+(`pnpm install --prod --config.node-linker=hoisted` then
+`pnpm pack --config.node-linker=hoisted`), so an offline profile can install
+the bundle without fetching them separately.
+
+This file records the origin, version and license of each bundled package. It
+is a human-readable provenance note, **not** a replacement for the license
+texts: every bundled package ships its own `LICENSE` file inside the tarball,
+and that packaged file is the authoritative text. The license names below come
+from the packaged `LICENSE` file and the package's own `package.json`; where
+either was ambiguous this file would say "see the packaged LICENSE" instead of
+naming one.
+
+## Bundled inventory
+
+| Package | Version | License | Location inside the tarball |
+|---|---|---|---|
+| `@deepseek-ai/dsh-tool-terminal` | `0.2.0-rc.1` | MIT | `package/node_modules/@deepseek-ai/dsh-tool-terminal/` |
+| `@deepseek-ai/schemastery` | `3.18.4` | MIT | `package/node_modules/@deepseek-ai/schemastery/` |
+| `@deepseek-ai/cosmokit` | `1.8.5` | MIT | `package/node_modules/@deepseek-ai/cosmokit/` |
+| `@standard-schema/spec` | `1.1.0` | MIT | `package/node_modules/@standard-schema/spec/` |
+
+Dependency edges, as declared by the packaged manifests:
+
+- `@deepseek-ai/dsh-tool-terminal@0.2.0-rc.1` → `@deepseek-ai/schemastery ~3.18.4`
+- `@deepseek-ai/schemastery@3.18.4` → `@standard-schema/spec ^1.1.0`, `@deepseek-ai/cosmokit ~1.8.5`
+- `@standard-schema/spec@1.1.0` and `@deepseek-ai/cosmokit@1.8.5` → no runtime dependencies
+
+Those four packages are the complete `node_modules/` inventory of the packed
+tarball; each of them includes its `LICENSE` file.
+
+## `@deepseek-ai/dsh-tool-terminal` 0.2.0-rc.1 — MIT
+
+- Origin: `git+https://github.com/deepseek-ai/deepseek-harness.git`, directory
+  `packages/terminal/tool-terminal` (from the packaged `package.json`
+  `repository`).
+- License: MIT (`package.json` `"license": "MIT"`), license text header
+  "MIT License", copyright notice `Copyright (c) 2026 DeepSeek`.
+- Role here: the six model-facing `terminal_*` tools mounted by the
+  `terminal-tools` row of this bundle's `cordis.patch.yml`. It is declared as a
+  `dependencies` + `bundledDependencies` entry of this package, not as a peer,
+  so it resolves from inside this package.
+
+## `@deepseek-ai/schemastery` 3.18.4 — MIT
+
+- Origin: `git+https://github.com/deepseek-ai/deepseek-harness.git`, directory
+  `vendor/schemastery` (from the packaged `package.json` `repository`).
+- License: MIT (`package.json` `"license": "MIT"`), license text header
+  "MIT License", copyright notice `Copyright (c) 2021-present Shigma`
+  (packaged `author`: `Shigma <shigma10826@gmail.com>`).
+- Role here: transitive runtime dependency of
+  `@deepseek-ai/dsh-tool-terminal`.
+
+## `@deepseek-ai/cosmokit` 1.8.5 — MIT
+
+- Origin: `git+https://github.com/deepseek-ai/deepseek-harness.git`, directory
+  `vendor/cosmokit` (from the packaged `package.json` `repository`).
+- License: MIT (`package.json` `"license": "MIT"`), license text header
+  "MIT License", copyright notice `Copyright (c) 2021-present Shigma`
+  (packaged `author`: `Shigma <shigma10826@gmail.com>`).
+- Role here: transitive runtime dependency of `@deepseek-ai/schemastery`.
+
+## `@standard-schema/spec` 1.1.0 — MIT
+
+- Origin: `https://github.com/standard-schema/standard-schema` (from the
+  packaged `package.json` `repository`; packaged `homepage`:
+  `https://standardschema.dev`).
+- License: MIT (`package.json` `"license": "MIT"`), license text header
+  "MIT License", copyright notice `Copyright (c) 2024 Colin McDonnell`
+  (packaged `author`: `Colin McDonnell`).
+- Role here: transitive runtime dependency of `@deepseek-ai/schemastery`.
+
+## Re-verifying this inventory
+
+After packing, list the tarball and check the four packages (and their
+`LICENSE` files) are present:
+
+```sh
+pnpm install --prod --config.node-linker=hoisted
+pnpm pack --config.node-linker=hoisted
+tar tzf banbolee-dsh-fish-shell-*.tgz | grep '^package/node_modules/'
+```
+
+Version bumps of the bundled dependency must update this file together with
+`dependencies` in `package.json` (the version pin is asserted by the
+plugin's contract tests).

package/cordis.patch.yml

@@ -52,3 +52,59 @@
 
     - id: fish-preset-policy
       name: '@banbolee/dsh-fish-shell/policy'
+# ── L2 interactive terminal sessions (fish-shell-tty-v3 §3.1) ───────────────────
+# A self-contained group: `isolate.terminals` keeps the `terminals` service
+# entry-local to the group (mounting it at the host plane would leave the entry
+# pending in profiles whose host plane has no `terminals` service). Inside it:
+#   - `pty`               the official terminal registry;
+#   - `terminal-fish-pty` this bundle's `terminal` module: the OFFICIAL
+#     `@deepseek-ai/dsh-terminal-bash` backend, driven with fish argv, PLUS the
+#     harness home contract (`DSH_HOME`, `DSH_PROFILE`, `DSH_PROFILE_DIR`) in
+#     the PTY child environment — the same facts the one-shot `fish` tool gets
+#     from `ctx.shellEnv`, so a nested `dsh` resolves the real harness home
+#     instead of `~/.dsh`. The row used to mount the official package directly;
+#     it cannot any more because that row has no `env` config field and its
+#     `childEnvironment()` is module-private, so owning the row is the only way
+#     to add the contract without editing or patching the official module.
+#     Everything else is still the official class (see `terminal.js`): the
+#     backend type stays `shell`, argv confinement and the sandbox-mode fence
+#     stay official, and readiness still comes from `session.initialize()`.
+#     The prompt setup rides in `-C` (startup submits nothing) so the motd stays
+#     clean — feeding the same setup through PTY input gets it echoed back by
+#     the fish line editor. The string below is FISH_PROMPT_SETUP from
+#     `terminal-fish.js` verbatim: the `\x1b` / `\x07` escapes must reach fish
+#     as literal backslash sequences for its `printf` to build the bytes at
+#     runtime (a contract test compares this value with the exported constant);
+#   - `terminal-tools`    the official tool package; `tools` is NOT isolated,
+#     so its six `terminal_*` tools register into the host registry and are
+#     visible to agents;
+#   - `fish-terminal-tools` this bundle's `terminalTools` policy, mounted in the
+#     same group so its scope matches the session surface (`deny` restricts the
+#     six explicit names per agent; `allow` is the default no-op).
+# The host-plane rows above (bash disabled + fish-shell/tool-fish/
+# fish-preset-policy) are untouched: `ctx.shell` and the one-shot `fish` tool
+# keep their exact code path.
+- insert:
+    - id: fish-terminal-group
+      name: 'cordis:group'
+      group: true
+      isolate:
+        terminals: true
+      config:
+        - id: pty
+          name: '@deepseek-ai/dsh-terminal'
+
+        - id: terminal-fish-pty
+          name: '@banbolee/dsh-fish-shell/terminal'
+          config:
+            shellPath: fish
+            shellArgs: ["--no-config","-i","-C","function fish_greeting; end; function fish_prompt; printf '\\x1b]133;D;%s\\x07' $status; echo -n 'dsh> '; end; function fish_right_prompt; end;"]
+            timeoutMs: 300000
+
+        - id: terminal-tools
+          name: '@deepseek-ai/dsh-tool-terminal'
+
+        - id: fish-terminal-tools
+          name: '@banbolee/dsh-fish-shell/terminal-tools'
+          config:
+            terminalTools: allow

package/node_modules/@deepseek-ai/cosmokit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@deepseek-ai/cosmokit/README.md

@@ -0,0 +1,30 @@
+# cosmokit
+
+[![Codecov](https://img.shields.io/codecov/c/github/shigma/cosmokit?style=flat-square)](https://codecov.io/gh/shigma/cosmokit)
+[![npm](https://img.shields.io/npm/v/cosmokit?style=flat-square)](https://www.npmjs.com/package/cosmokit)
+
+A collection of common utilities.
+
+## Usage
+
+### Node.js
+
+```sh
+npm install cosmokit
+```
+
+```ts
+import cosmokit from 'cosmokit'
+``` 
+
+### Deno
+
+```ts
+import cosmokit from 'npm:cosmokit@latest'
+```
+
+## Config references
+
+`Volatile<T>` exposes `get()` for immutable data snapshots. `createVolatile()` copies and freezes validated data; framework-owned `updateVolatile()` transfers a candidate snapshot into an existing reference. Framework-owned `volatileEntries()` enumerates references and their paths through plain config containers, stopping at snapshots and opaque objects. The shared symbol protocol recognizes references across ESM/CJS copies. Plugin consumers import the type from Cordis and retain the reference rather than caching values between operations.
+
+`deepEqual()` treats two volatile references as equal regardless of their snapshots. Strict comparisons distinguish null from undefined recursively, compare URLs by normalized `href` and other opaque objects by identity, and treat distinct cyclic structures as unequal. Array comparison visits every index and treats holes as undefined. Snapshot-change detection must compare `.get()` results separately.

package/node_modules/@deepseek-ai/cosmokit/lib/index.js

@@ -0,0 +1,418 @@
+//#region lib/types/misc.js
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+function noop() {}
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true when a value is neither `null` nor `undefined`. */
+function isNonNullable(value) {
+	return !isNullable(value);
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Omit selected keys from a shallow object copy. */
+function omit(source, keys) {
+	if (!keys) return { ...source };
+	const result = { ...source };
+	for (const key of keys) Reflect.deleteProperty(result, key);
+	return result;
+}
+/** Define a non-enumerable writable property and return the object. */
+function defineProperty(object, key, value) {
+	return Object.defineProperty(object, key, {
+		writable: true,
+		value,
+		enumerable: false
+	});
+}
+//#endregion
+//#region lib/types/array.js
+/** Return true when every item in `array2` is present in `array1`. */
+function contain(array1, array2) {
+	return array2.every((item) => array1.includes(item));
+}
+/** Return items that appear in both arrays. */
+function intersection(array1, array2) {
+	return array1.filter((item) => array2.includes(item));
+}
+/** Return items from `array1` that do not appear in `array2`. */
+function difference(array1, array2) {
+	return array1.filter((item) => !array2.includes(item));
+}
+/** Return the set-union of two arrays while preserving first occurrence order. */
+function union(array1, array2) {
+	return Array.from(new Set([...array1, ...array2]));
+}
+/** Remove duplicate values while preserving first occurrence order. */
+function deduplicate(array) {
+	return [...new Set(array)];
+}
+/** Remove one item from an array and report whether it was found. */
+function remove(list, item) {
+	const index = list?.indexOf(item);
+	if (index >= 0) {
+		list.splice(index, 1);
+		return true;
+	} else return false;
+}
+/** Normalize nullish, scalar, or array input to an array. */
+function makeArray(source) {
+	return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+//#endregion
+//#region lib/types/volatile.js
+/** Shared config references used by schema validators and plugin runtimes. */
+const write = Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+		return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/**
+* Create a detached reference containing an immutable copy of the supplied data.
+* @param value - validated config data; class instances and functions are unsupported.
+* @returns a reference whose value is updated only by its owning runtime.
+*/
+function createVolatile(value) {
+	let current = snapshot(value);
+	return Object.freeze({
+		get: () => current,
+		[write]: (value) => {
+			current = value;
+		}
+	});
+}
+/**
+* Identify references across ESM/CJS copies of the shared library.
+* @param value - a parsed config value.
+* @returns whether the value implements the shared reference protocol.
+*/
+function isVolatile(value) {
+	return typeof value === "object" && value !== null && write in value;
+}
+/**
+* Collect config references without descending into their snapshots or opaque objects.
+* @internal
+* @param value - parsed config; cyclic ordinary fields are visited once per path.
+* @returns references and their object-key paths, including an empty path for a root reference.
+*/
+function volatileEntries(value) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function visit(value, path) {
+		if (isVolatile(value)) return [{
+			path,
+			ref: value
+		}];
+		if (!value || typeof value !== "object" || ancestors.has(value)) return [];
+		if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return [];
+		ancestors.add(value);
+		try {
+			return Object.entries(value).flatMap(([key, child]) => visit(child, [...path, key]));
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	return visit(value, []);
+}
+/**
+* Commit an already validated immutable snapshot from another reference.
+* @internal
+* @param target - the owning plugin's stable reference.
+* @param source - a newly parsed candidate reference.
+*/
+function updateVolatile(target, source) {
+	target[write](source.get());
+}
+//#endregion
+//#region lib/types/types.js
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+/** Decode a base64 string into binary data. */
+const base64ToArrayBuffer = Binary.fromBase64;
+/** Encode binary data as base64. */
+const arrayBufferToBase64 = Binary.toBase64;
+/** Decode a hex string into binary data. */
+const hexToArrayBuffer = Binary.fromHex;
+/** Encode binary data as hex. */
+const arrayBufferToHex = Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/**
+* Compare values recursively, treating two volatile references as equal regardless of value.
+* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+* @param a - first value.
+* @param b - second value.
+* @param strict - whether to require strict data equality outside volatile references.
+* @returns whether the values compare equal.
+*/
+function deepEqual(a, b, strict) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function compare(a, b) {
+		if (a === b) return true;
+		if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b);
+		if (!strict && isNullable(a) && isNullable(b)) return true;
+		if (typeof a !== typeof b || typeof a !== "object" || !a || !b) return false;
+		if (ancestors.has(a)) return false;
+		function check(test, then) {
+			return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+		}
+		ancestors.add(a);
+		try {
+			return check(Array.isArray, (a, b) => {
+				if (a.length !== b.length) return false;
+				for (let index = 0; index < a.length; index++) if (!compare(a[index], b[index])) return false;
+				return true;
+			}) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("URL"), (a, b) => a.href === b.href) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+				if (a.byteLength !== b.byteLength) return false;
+				const viewA = new Uint8Array(a);
+				const viewB = new Uint8Array(b);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? ((!strict || [a, b].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+				...a,
+				...b
+			}).every((key) => compare(a[key], b[key])));
+		} finally {
+			ancestors.delete(a);
+		}
+	}
+	return compare(a, b);
+}
+//#endregion
+//#region lib/types/string.js
+/** Uppercase the first character of a string. */
+function capitalize(source) {
+	return source.charAt(0).toUpperCase() + source.slice(1);
+}
+/** Lowercase the first character of a string. */
+function uncapitalize(source) {
+	return source.charAt(0).toLowerCase() + source.slice(1);
+}
+/** Convert dash or underscore delimited text to camelCase. */
+function camelCase(source) {
+	return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
+}
+function tokenize(source, delimiters, delimiter) {
+	const output = [];
+	let state = 0;
+	for (let i = 0; i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code >= 65 && code <= 90) {
+			if (state === 1) {
+				const next = source.charCodeAt(i + 1);
+				if (next >= 97 && next <= 122) output.push(delimiter);
+				output.push(code + 32);
+			} else {
+				if (state !== 0) output.push(delimiter);
+				output.push(code + 32);
+			}
+			state = 1;
+		} else if (code >= 97 && code <= 122) {
+			output.push(code);
+			state = 2;
+		} else if (delimiters.includes(code)) {
+			if (state !== 0) output.push(delimiter);
+			state = 0;
+		} else output.push(code);
+	}
+	return String.fromCharCode(...output);
+}
+/** Convert text to dash-delimited parameter case. */
+function paramCase(source) {
+	return tokenize(source, [45, 95], 45);
+}
+/** Convert text to underscore-delimited snake case. */
+function snakeCase(source) {
+	return tokenize(source, [45, 95], 95);
+}
+/** Runtime alias for `camelCase`. */
+const camelize = camelCase;
+/** Runtime alias for `paramCase`. */
+const hyphenate = paramCase;
+/** Format a property key as a JavaScript member access suffix. */
+function formatProperty(key) {
+	if (typeof key !== "string") return `[${key.toString()}]`;
+	return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+/** Remove one trailing slash from a path string. */
+function trimSlash(source) {
+	return source.replace(/\/$/, "");
+}
+/** Ensure a path starts with `/` and has no trailing slash. */
+function sanitize(source) {
+	if (!source.startsWith("/")) source = "/" + source;
+	return trimSlash(source);
+}
+//#endregion
+//#region lib/types/time.js
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+export { Binary, Time, arrayBufferToBase64, arrayBufferToHex, base64ToArrayBuffer, camelCase, camelize, capitalize, clone, contain, createVolatile, deduplicate, deepEqual, defineProperty, difference, filterKeys, formatProperty, hexToArrayBuffer, hyphenate, intersection, is, isNonNullable, isNullable, isPlainObject, isVolatile, makeArray, mapValues, mapValues as valueMap, noop, omit, paramCase, pick, remove, sanitize, snakeCase, trimSlash, uncapitalize, union, updateVolatile, volatileEntries };

package/node_modules/@deepseek-ai/cosmokit/lib/types/array.d.ts

@@ -0,0 +1,15 @@
+/** Return true when every item in `array2` is present in `array1`. */
+export declare function contain(array1: readonly any[], array2: readonly any[]): boolean;
+/** Return items that appear in both arrays. */
+export declare function intersection<T>(array1: readonly T[], array2: readonly T[]): T[];
+/** Return items from `array1` that do not appear in `array2`. */
+export declare function difference<S>(array1: readonly S[], array2: readonly any[]): S[];
+/** Return the set-union of two arrays while preserving first occurrence order. */
+export declare function union<T>(array1: readonly T[], array2: readonly T[]): T[];
+/** Remove duplicate values while preserving first occurrence order. */
+export declare function deduplicate<T>(array: readonly T[]): T[];
+/** Remove one item from an array and report whether it was found. */
+export declare function remove<T>(list: T[], item: T): boolean;
+/** Normalize nullish, scalar, or array input to an array. */
+export declare function makeArray<T>(source: null | undefined | T | T[]): T[];
+//# sourceMappingURL=array.d.ts.map

package/node_modules/@deepseek-ai/cosmokit/lib/types/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/array.ts"],"names":[],"mappings":"AAEA,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,EAAE,EAAE,MAAM,EAAE,SAAS,GAAG,EAAE,WAErE;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAEzE;AAED,iEAAiE;AACjE,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,GAAG,EAAE,OAEzE;AAED,kFAAkF;AAClF,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAElE;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,OAEjD;AAED,qEAAqE;AACrE,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,WAQ3C;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,CAAC,GAAG,CAAC,EAAE,OAE9D"}

package/node_modules/@deepseek-ai/cosmokit/lib/types/index.d.ts

@@ -0,0 +1,13 @@
+/** Array set and normalization helpers. */
+export * from './array.ts';
+/** Runtime type, binary, clone, and equality helpers. */
+export * from './types.ts';
+/** Shared utility types and object helpers. */
+export * from './misc.ts';
+/** String case, path, and property formatting helpers. */
+export * from './string.ts';
+/** Time constants, parsing, and formatting helpers. */
+export * from './time.ts';
+/** Immutable config references shared by schema validators and runtimes. */
+export * from './volatile.ts';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@deepseek-ai/cosmokit/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,cAAc,YAAY,CAAA;AAC1B,yDAAyD;AACzD,cAAc,YAAY,CAAA;AAC1B,+CAA+C;AAC/C,cAAc,WAAW,CAAA;AACzB,0DAA0D;AAC1D,cAAc,aAAa,CAAA;AAC3B,uDAAuD;AACvD,cAAc,WAAW,CAAA;AACzB,4EAA4E;AAC5E,cAAc,eAAe,CAAA"}