better-dsh 0.2.3 → 0.2.4

package/lib/lsp-server-registry-_hk-Wcia.js

@@ -0,0 +1,3 @@
+import { a as primaryServerForFile, c as serversForFile, i as installServer, n as findWorkspaceRoot, o as resolveCommandPath, r as installHintFor, s as serverByName, t as clearCommandProbeCache } from "./lsp-server-registry-DkaYmTwt.js";
+
+export { clearCommandProbeCache, findWorkspaceRoot, installHintFor, installServer, primaryServerForFile, resolveCommandPath, serverByName, serversForFile };

package/lib/py-sdk-Chvy92MB.js

@@ -0,0 +1,178 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region src/vendored/repl-runtime.ts
+/**
+* Binding globals EVERY backend refuses because SOME backend owns the slot in
+* the program's namespace: `console` (the worker's log capture), and
+* `__dsh_main__`/`__builtins__`/`__name__` (the Python backend's bootstrap
+* wrapper and seeded module globals; see upstream's Agent Note
+* `2026-07-31-code-runtime-portable-identifier-seam.md` in the dsh monorepo),
+* and `__debug__`. One shared set — rather than each backend refusing only its
+* own slots — keeps the portability promise real: a namespace list valid on
+* one backend is valid on all, so a caller cannot pick a name that works on
+* the worker and collides on Python (or vice versa). `__name__` et al. ARE
+* valid portable identifiers, so the identifier rule on
+* `CodeBindingNamespace.global` never rejects them — hence this explicit set.
+* (Error members differ: {@link DUNDER_MEMBER} refuses every dunder form
+* wholesale; binding globals refuse only the names listed here.) `__debug__`
+* is listed for a different reason than a collision: CPython compiles a bare
+* `__debug__` reference to the constant `True` and rejects any assignment to
+* the name at COMPILE time, so an injected global under that name is
+* unreachable from the program — accepted by validation, unusable on the
+* Python backend, which is exactly the split the shared set exists to prevent.
+*/
+const RESERVED_BINDING_GLOBALS = new Set([
+	"console",
+	"__dsh_main__",
+	"__builtins__",
+	"__name__",
+	"__debug__"
+]);
+/**
+* `CodeBindingErrorClass.memberNameProperty` names EVERY backend refuses, as
+* one shared contract so a request valid on one backend is valid on all. The
+* JS `Error` exclusions (`name`, `message`, `stack`) and Python's
+* exception-protocol members (`args`, `with_traceback`, `add_note`) are
+* listed by name; dunder-form names (`__x__`, non-empty middle) are refused
+* wholesale — several are constrained CPython descriptors whose `setattr`
+* raises while constructing the rejection, and the exact set is an interpreter
+* version detail. Any other non-empty own property name is accepted everywhere.
+*/
+const RESERVED_ERROR_MEMBERS = new Set([
+	"name",
+	"message",
+	"stack",
+	"args",
+	"with_traceback",
+	"add_note"
+]);
+/**
+* Dunder form (`__x__`, non-empty middle): object-protocol slots in Python,
+* refused as {@link RESERVED_ERROR_MEMBERS | error members} on every backend.
+*/
+const DUNDER_MEMBER = /^__.+__$/;
+/**
+* Reserved words of every portable target language (ECMAScript ∪ Python),
+* refused as {@link CodeBindingNamespace.global} / error-class names by all
+* backends. Python is a portability target here even though only the
+* TypeScript worker has a published backend. The portable-identifier contract
+* promises a namespace list valid on one backend is valid on every backend; a
+* per-language check would let `lambda` pass the TypeScript backend and fail
+* the Python one. Extending the seam with a new language means widening this
+* union (a breaking review of existing binding names, by design).
+*/
+const PORTABLE_RESERVED_WORDS = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"let",
+	"static",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"arguments",
+	"eval",
+	"False",
+	"None",
+	"True",
+	"and",
+	"as",
+	"assert",
+	"async",
+	"def",
+	"del",
+	"elif",
+	"except",
+	"from",
+	"global",
+	"is",
+	"lambda",
+	"nonlocal",
+	"not",
+	"or",
+	"pass",
+	"raise",
+	"match",
+	"type",
+	"_"
+]);
+/**
+* Registers one `ctx.replRuntime` implementation. Program, budget, abort, and substrate
+* failures resolve in {@link CodeRunResult}; only Service Definition contract misuse rejects. Implementations bridge
+* structured-cloneable bindings, materialize each declared namespace rejection
+* class, treat programs as hostile peers — budget, interrupt, and substrate
+* semantics apply per program and are unchanged by this seam's statefulness —
+* share one persistent per-session user namespace across runs (state
+* codification across runs IS the product; this replaces upstream's
+* isolate-runs-from-one-another clause), and terminate and await in-flight
+* runs during disposal.
+*/
+var ReplRuntime = class extends Service {
+	constructor(ctx) {
+		super(ctx, "replRuntime");
+	}
+};
+
+//#endregion
+//#region src/py-sdk.ts
+/** The language-portable identifier subset the seam accepts as a binding global (mirrors the runtime's private rule). */
+const PORTABLE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Whether a tool name can be bound as a `tool` member — the ONE
+* policy the bridge's binding loop (src/index.ts) applies, so the
+* bindings never promise a name the kernel does
+* not bind. Strictly narrower than the runtime's validation: the
+* language-portable identifier subset (`[A-Za-z_][A-Za-z0-9_]*`, ASCII — a
+* non-ASCII XID name is legal CPython but not portable, so the runtime
+* refuses it as a binding global), minus
+* every portable reserved word (ECMAScript ∪ Python — `type` and `match`
+* are legal Python but reserved on the seam), minus the seam's reserved
+* binding globals (`console`, dunders), minus underscore-leading names
+* (kernel-shim prefix plus the call-site hazards; not callable as taught
+* flat globals). The runtime's `validateBindings` remains the authoritative
+* backstop: everything this accepts, it accepts.
+*/
+function isFlatBindableName(name) {
+	return PORTABLE_IDENTIFIER.test(name) && !name.startsWith("_") && !PORTABLE_RESERVED_WORDS.has(name) && !RESERVED_BINDING_GLOBALS.has(name);
+}
+
+//#endregion
+export { RESERVED_ERROR_MEMBERS as a, RESERVED_BINDING_GLOBALS as i, DUNDER_MEMBER as n, ReplRuntime as o, PORTABLE_RESERVED_WORDS as r, isFlatBindableName as t };

package/lib/py-sdk.d.ts

@@ -1,2 +1,19 @@
-import { a as renderReplBridgeInstructions, i as isFlatBindableName, n as REPL_BRIDGE_CATALOG_MODE, o as renderToolsSdkPy, r as ReplBridgeCatalogMode, t as DASHRSdkSchema } from "./py-sdk-BCaOGYz7.js";
-export { DASHRSdkSchema, REPL_BRIDGE_CATALOG_MODE, ReplBridgeCatalogMode, isFlatBindableName, renderReplBridgeInstructions, renderToolsSdkPy };
+//#region src/py-sdk.d.ts
+/**
+ * Whether a tool name can be bound as a `tool` member — the ONE
+ * policy the bridge's binding loop (src/index.ts) applies, so the
+ * bindings never promise a name the kernel does
+ * not bind. Strictly narrower than the runtime's validation: the
+ * language-portable identifier subset (`[A-Za-z_][A-Za-z0-9_]*`, ASCII — a
+ * non-ASCII XID name is legal CPython but not portable, so the runtime
+ * refuses it as a binding global), minus
+ * every portable reserved word (ECMAScript ∪ Python — `type` and `match`
+ * are legal Python but reserved on the seam), minus the seam's reserved
+ * binding globals (`console`, dunders), minus underscore-leading names
+ * (kernel-shim prefix plus the call-site hazards; not callable as taught
+ * flat globals). The runtime's `validateBindings` remains the authoritative
+ * backstop: everything this accepts, it accepts.
+ */
+declare function isFlatBindableName(name: string): boolean;
+//#endregion
+export { isFlatBindableName };

package/lib/py-sdk.js

@@ -1,3 +1,3 @@
-import { i as renderToolsSdkPy, n as isFlatBindableName, r as renderReplBridgeInstructions, t as REPL_BRIDGE_CATALOG_MODE } from "./py-sdk-CbgYiX8O.js";
+import { t as isFlatBindableName } from "./py-sdk-Chvy92MB.js";
 
-export { REPL_BRIDGE_CATALOG_MODE, isFlatBindableName, renderReplBridgeInstructions, renderToolsSdkPy };
+export { isFlatBindableName };