@bolt-foundry/gambit 0.5.3-dev.1

package/CHANGELOG.md

@@ -0,0 +1,85 @@
++++
+[release]
+since = "b0ddcc2ba4e861e0879dc92cc713e8cde30d230f"
++++
+
+# Changelog
+
+## Unreleased (v0.6.0)
+
+- TBD
+
+## v0.5.0
+
+### Runtime and API
+
+- Synthetic tools refreshed: `gambit_init`, `gambit_respond`, `gambit_complete`
+  (function-style tools, underscore names).
+- Envelope simplification: init carries run/action IDs plus guardrails/model
+  hints; respond wraps payload/message/status/code/meta (default status 200 for
+  success, 500 for handled errors unless overridden).
+- Runtime behavior: child completions and handled errors emit `gambit_complete`;
+  interval handlers surface mid-run updates; roots stay conversational-only.
+- `gambit_init` only fires when `--init` is provided and its payload is the raw
+  input (no run/action metadata).
+- Added trace timestamps for latency metrics and persisted streamed assistant
+  text before tool calls.
+- Added OpenAI chat completions compatibility (`renderDeck` plus wrapper).
+- Increased default guardrail `maxPasses`.
+
+### Simulator UI and test bot
+
+- New React simulator UI with sessions, recents, nested trace hierarchy, and
+  session notes/ratings.
+- Pivoted the simulator to debug/test/calibrate workflows with a new editor
+  assistant endpoint and UI tab.
+- Test bot upgrades: per-run streaming + debug link, init/scenario panels,
+  default scenario schema, deck input config, feedback on all bubbles, and
+  session routing/persistence.
+- Calibration/grading updates: deck-defined grading flows, streamed results,
+  reference samples, compact context previews, and renaming calibration runs to
+  grading runs.
+
+### Decks and examples (voice front desk)
+
+- Added voice front desk example decks and modularized the deck set.
+- Added new patient intake + additional voice front desk test decks.
+- Added appointment lookup orchestration and scheduling confirmation flow.
+- Enabled scheduling service deck and shared patient identity test input schema.
+- Replaced voice front desk graders and expanded FAQ persona/grading coverage.
+
+### CLI and UX
+
+- Added a grading command with test-bot hooks in the CLI.
+- `--message` now works without `--init` for object root schemas.
+- REPL/serve/CLI flags refreshed; `--verbose` logs tool call args/results.
+
+### Fixes
+
+- Avoid extra assistant turn on test-bot resume; skip empty assistant turns in
+  grading; keep grader respond blocks last.
+- Fixed test-bot sidebar loading, grader score reads, and booking confirmation
+  placement.
+- Simulator UI polish: full-height layout, sourcemap adverts, locked init panel
+  behavior, and reconnect/permalink reloads.
+
+## v0.0
+
+- Authoring: TypeScript/Markdown decks and cards via `defineDeck`/`defineCard`;
+  embeds with cycle detection; card actions merge into decks (deck wins); card
+  schema fragments merge into deck schemas; non-root decks require input/output
+  schemas (root defaults to string-ish).
+- Runtime: compute and LLM decks share the surface; assistant-first flow seeds a
+  synthetic `gambit_init` tool; helpers `spawnAndWait`, `return`, `fail`; action
+  names validated against reserved prefix/pattern/length; default guardrails
+  depth=3/passes=3/timeout≈120s with per-deck overrides.
+- Handlers/events: optional `onError`/`onBusy`/`onIdle` decks emit structured
+  events (`gambit_complete` for handled errors, busy/idle updates) with default
+  delay 800ms and traces for fire/result (`onInterval` is deprecated alias for
+  `onBusy`).
+- IO/host: CLI supports `run`, `repl`, `serve` (WebSocket simulator UI); flags
+  for streaming, turn order via user message, trace to console/JSONL, state
+  load/save, model overrides; `deno task compile` builds a binary; OpenRouter
+  chat provider with streaming/tool calls.
+- Runtime + server tests for schemas/embeds/streaming/handlers; tasks for
+  fmt/lint/test/ci; root README with quick start.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,236 @@
+# Gambit (draft README)
+
+This package is developed in Bolt Foundry’s monorepo and mirrored into
+`github.com/bolt-foundry/gambit`. For now, that repo is a strict mirror (please
+do not land direct changes there).
+
+CI runs `.github/workflows/gambit-mirror.yml` on every `main` push that touches
+this package, using `scripts/sync-gambit-mirror.sh` to open and auto-merge a PR
+from the `bft-codebot` fork into the public mirror.
+
+Gambit helps developers build the most accurate LLM apps by making it simple to
+provide exactly the right amount of context at the right time.
+
+## Status quo
+
+- Most teams wire one long prompt to several tools and hope the model routes
+  correctly.
+- Context often arrives as a single giant fetch or RAG blob, so costs climb and
+  hallucinations slip in.
+- Input/outputs are rarely typed, which makes orchestration brittle and hard to
+  test offline.
+- Debugging leans on provider logs instead of local traces, so reproducing
+  failures is slow.
+
+## Our vision
+
+- Treat each step as a small deck with explicit inputs/outputs and guardrails;
+  model calls are just one kind of action.
+- Mix LLM and compute tasks interchangeably and effortlessly inside the same
+  deck tree.
+- Feed models only what they need per step; inject references and cards instead
+  of dumping every document.
+- Keep orchestration logic local and testable; run decks offline with
+  predictable traces.
+- Ship with built-in observability (streaming, REPL, debug UI) so debugging
+  feels like regular software, not guesswork.
+
+## 5-minute quickstart
+
+Requirements: Deno 2.2+ and `OPENROUTER_API_KEY` (set `OPENROUTER_BASE_URL` if
+you proxy OpenRouter-style APIs).
+
+Run the CLI directly from JSR (no install):
+
+```sh
+export OPENROUTER_API_KEY=...
+deno run -A jsr:@bolt-foundry/gambit/cli --help
+```
+
+Run a packaged example without cloning:
+
+```sh
+export OPENROUTER_API_KEY=...
+deno run -A jsr:@bolt-foundry/gambit/cli run --example hello_world.deck.md --init '"hi"'
+```
+
+Run the built-in assistant (from a clone of this repo):
+
+```sh
+export OPENROUTER_API_KEY=...
+deno run -A src/cli.ts run src/decks/gambit-assistant.deck.md --init '"hi"' --stream
+```
+
+Talk to it in a REPL (default deck is `src/decks/gambit-assistant.deck.md`):
+
+```sh
+deno run -A src/cli.ts repl --message '"hello"' --stream --verbose
+```
+
+Open the debug UI:
+
+```sh
+deno run -A src/cli.ts serve src/decks/gambit-assistant.deck.md --port 8000
+open http://localhost:8000/debug
+```
+
+Install the CLI once (uses the published JSR package):
+
+```sh
+deno install -A -n gambit jsr:@bolt-foundry/gambit/cli
+gambit run path/to/root.deck.ts --init '"hi"'
+```
+
+If you run from a remote URL (e.g., `jsr:@bolt-foundry/gambit/cli`), pass an
+explicit deck path; the default REPL deck only exists in a local checkout.
+
+## Author your first deck
+
+Minimal Markdown deck (model-powered):
+
+```md
++++
+label = "hello_world"
+
+[modelParams]
+model = "openai/gpt-4o-mini"
+temperature = 0
++++
+
+You are a concise assistant. Greet the user and echo the input.
+```
+
+Run it:
+
+```sh
+deno run -A src/cli.ts run ./hello_world.deck.md --init '"Gambit"' --stream
+```
+
+Compute deck in TypeScript (no model call):
+
+```ts
+// echo.deck.ts
+import { defineDeck } from "jsr:@bolt-foundry/gambit";
+import { z } from "zod";
+
+export default defineDeck({
+  label: "echo",
+  inputSchema: z.object({ text: z.string() }),
+  outputSchema: z.object({ text: z.string(), length: z.number() }),
+  run(ctx) {
+    return { text: ctx.input.text, length: ctx.input.text.length };
+  },
+});
+```
+
+Run it:
+
+```sh
+deno run -A src/cli.ts run ./echo.deck.ts --init '{"text":"ping"}'
+```
+
+Deck with a child action (calls a TypeScript tool):
+
+```md
++++
+label = "agent_with_time"
+modelParams = { model = "openai/gpt-4o-mini", temperature = 0 }
+actionDecks = [
+  { name = "get_time", path = "./get_time.deck.ts", description = "Return the current ISO timestamp." },
+]
++++
+
+A tiny agent that calls get_time, then replies with the timestamp and the input.
+```
+
+And the child action:
+
+```ts
+// get_time.deck.ts
+import { defineDeck } from "jsr:@bolt-foundry/gambit";
+import { z } from "zod";
+
+export default defineDeck({
+  label: "get_time",
+  inputSchema: z.object({}), // no args
+  outputSchema: z.object({ iso: z.string() }),
+  run() {
+    return { iso: new Date().toISOString() };
+  },
+});
+```
+
+## Repo highlights
+
+- CLI entry: `src/cli.ts`; runtime: `src/runtime.ts`; definitions: `mod.ts`.
+- Examples: `examples/hello_world.deck.md`,
+  `examples/agent_with_multi_actions/`.
+- Debug UI assets: `src/server.ts` (built-in UI now renders schema-driven init
+  forms beneath the user message box with a raw JSON tab, reconnect button, and
+  a trace-formatting hook).
+- Tests/lint/format: `deno task test`, `deno task lint`, `deno task fmt`;
+  compile binary: `deno task compile`.
+- Docs index: `docs/README.md`; authoring guide: `docs/authoring.md`; prompting
+  notes: `docs/hourglass.md`; changelog: `CHANGELOG.md`.
+
+## Docs
+
+- Authoring decks/cards: `docs/authoring.md`
+- Runtime/guardrails: `docs/runtime.md`
+- CLI, REPL, debug UI: `docs/cli.md`
+- Examples guide: `docs/examples.md`
+- OpenAI Chat Completions compatibility: `docs/openai-compat.md`
+
+## OpenAI Chat Completions compatibility
+
+If you already construct OpenAI Chat Completions-style requests, you can use
+Gambit as a drop-in-ish wrapper that applies a deck prompt and can execute only
+deck-defined tools (action decks).
+
+```ts
+import {
+  chatCompletionsWithDeck,
+  createOpenRouterProvider,
+} from "jsr:@bolt-foundry/gambit";
+
+const provider = createOpenRouterProvider({
+  apiKey: Deno.env.get("OPENROUTER_API_KEY")!,
+});
+
+const resp = await chatCompletionsWithDeck({
+  deckPath: "./path/to/root.deck.md",
+  modelProvider: provider,
+  request: {
+    model: "openai/gpt-4o-mini",
+    messages: [{ role: "user", content: "hello" }],
+  },
+});
+
+console.log(resp.choices[0].message);
+```
+
+## Handlers (error/busy/idle)
+
+- Decks may declare `handlers` with `onError`, `onBusy`, and `onIdle`.
+  `onInterval` is still accepted but deprecated (alias for `onBusy`).
+- Busy handler input:
+  `{kind:"busy", source:{deckPath, actionName}, trigger:{reason:"timeout", elapsedMs}, childInput}`
+  plus `delayMs`/`repeatMs` knobs.
+- Idle handler input:
+  `{kind:"idle", source:{deckPath}, trigger:{reason:"idle_timeout", elapsedMs}}`
+  with `delayMs` (and optional `repeatMs` if provided).
+- Error handler input: `{kind:"error", source, error:{message}, childInput}` and
+  should return an envelope `{message?, code?, status?, meta?, payload?}`.
+- Example implementations live under `examples/handlers_ts` and
+  `examples/handlers_md`.
+- Debug UI streams handler output in a “status” lane (busy/idle) separate from
+  assistant turns.
+
+## Next steps
+
+- Swap `modelParams.model` or pass `--model`/`--model-force` to test other
+  providers.
+- Add `actionDecks` to a deck and call child decks; use `spawnAndWait` inside
+  compute decks.
+- Use `--stream` and `--verbose` while iterating; pass `--trace <file>` to
+  capture JSONL traces.

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,25 @@
+declare global {
+    interface ImportMeta {
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         */
+        resolve(specifier: string): string;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;WAOG;QAEH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;KACpC;CACF;AAED,OAAO,EAAE,CAAA"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1 @@
+export {};

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,61 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.d.ts

@@ -0,0 +1,2 @@
+export declare function checkWindows(): boolean;
+//# sourceMappingURL=_os.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/_os.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,IAAI,OAAO,CAUtC"}

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.js

@@ -0,0 +1,12 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+export function checkWindows() {
+    // deno-lint-ignore no-explicit-any
+    const global = dntShim.dntGlobalThis;
+    const os = global.Deno?.build?.os;
+    // Check Deno, then the remaining runtimes (e.g. Node, Bun and the browser)
+    return typeof os === "string"
+        ? os === "windows"
+        : global.navigator?.platform?.startsWith("Win") ??
+            global.process?.platform?.startsWith("win") ?? false;
+}

package/esm/deps/jsr.io/@std/internal/1.0.12/os.d.ts

@@ -0,0 +1,3 @@
+/** Whether the current platform is Windows */
+export declare const isWindows: boolean;
+//# sourceMappingURL=os.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.12/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}

package/esm/deps/jsr.io/@std/internal/1.0.12/os.js

@@ -0,0 +1,5 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { checkWindows } from "./_os.js";
+/** Whether the current platform is Windows */
+export const isWindows = checkWindows();

package/esm/deps/jsr.io/@std/path/1.1.4/_common/assert_path.d.ts

@@ -0,0 +1,2 @@
+export declare function assertPath(path?: string): void;
+//# sourceMappingURL=assert_path.d.ts.map

package/esm/deps/jsr.io/@std/path/1.1.4/_common/assert_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}