@bolt-foundry/gambit 0.5.3-dev.1

package/esm/gambit-core/src/providers/openrouter.js

@@ -0,0 +1,168 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import OpenAI from "openai";
+const logger = console;
+function normalizeMessage(content) {
+    const toolCalls = content.tool_calls ??
+        undefined;
+    return {
+        role: content.role,
+        content: typeof content.content === "string"
+            ? content.content
+            : Array.isArray(content.content)
+                ? content.content
+                    .map((c) => (typeof c === "string" ? c : ""))
+                    .join("")
+                : "",
+        name: content.name,
+        tool_call_id: content.tool_call_id,
+        tool_calls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
+    };
+}
+export function createOpenRouterProvider(opts) {
+    const debugStream = dntShim.Deno.env.get("GAMBIT_DEBUG_STREAM") === "1";
+    const client = new OpenAI({
+        apiKey: opts.apiKey,
+        baseURL: opts.baseURL ?? "https://openrouter.ai/api/v1",
+        defaultHeaders: {
+            "HTTP-Referer": opts.referer ?? "https://gambit.local",
+            "X-Title": opts.title ?? "Gambit CLI",
+        },
+    });
+    return {
+        async chat(input) {
+            const params = input.params ?? {};
+            if (input.stream) {
+                if (debugStream) {
+                    logger.log(`[stream-debug] requesting stream model=${input.model} messages=${input.messages.length} tools=${input.tools?.length ?? 0}`);
+                }
+                const stream = await client.chat.completions.create({
+                    model: input.model,
+                    messages: input
+                        .messages,
+                    tools: input
+                        .tools,
+                    tool_choice: "auto",
+                    stream: true,
+                    ...params,
+                });
+                let finishReason = null;
+                const contentParts = [];
+                const toolCallMap = new Map();
+                let chunkCount = 0;
+                let streamedChars = 0;
+                for await (const chunk of stream) {
+                    chunkCount++;
+                    const choice = chunk.choices[0];
+                    const fr = choice.finish_reason;
+                    if (fr === "stop" || fr === "tool_calls" || fr === "length" ||
+                        fr === null) {
+                        finishReason = fr ?? finishReason;
+                    }
+                    const delta = choice.delta;
+                    if (typeof delta.content === "string") {
+                        contentParts.push(delta.content);
+                        input.onStreamText?.(delta.content);
+                        streamedChars += delta.content.length;
+                    }
+                    else if (Array.isArray(delta.content)) {
+                        const chunkStr = delta.content
+                            .map((c) => (typeof c === "string" ? c : ""))
+                            .join("");
+                        if (chunkStr) {
+                            contentParts.push(chunkStr);
+                            input.onStreamText?.(chunkStr);
+                            streamedChars += chunkStr.length;
+                        }
+                    }
+                    for (const tc of delta.tool_calls ?? []) {
+                        const idx = tc.index ?? 0;
+                        const existing = toolCallMap.get(idx) ??
+                            {
+                                id: tc.id,
+                                function: { name: tc.function?.name, arguments: "" },
+                            };
+                        if (tc.id)
+                            existing.id = tc.id;
+                        if (tc.function?.name)
+                            existing.function.name = tc.function.name;
+                        if (tc.function?.arguments) {
+                            existing.function.arguments += tc.function.arguments;
+                        }
+                        toolCallMap.set(idx, existing);
+                    }
+                }
+                if (debugStream) {
+                    logger.log(`[stream-debug] completed stream chunks=${chunkCount} streamedChars=${streamedChars} finishReason=${finishReason}`);
+                }
+                const tool_calls = Array.from(toolCallMap.values()).map((tc) => ({
+                    id: tc.id ?? crypto.randomUUID().replace(/-/g, "").slice(0, 24),
+                    type: "function",
+                    function: {
+                        name: tc.function.name ?? "",
+                        arguments: tc.function.arguments,
+                    },
+                }));
+                const message = normalizeMessage({
+                    role: "assistant",
+                    content: contentParts.length ? contentParts.join("") : null,
+                    tool_calls,
+                });
+                const toolCalls = tool_calls.length > 0
+                    ? tool_calls.map((tc) => ({
+                        id: tc.id,
+                        name: tc.function.name,
+                        args: safeJson(tc.function.arguments),
+                    }))
+                    : undefined;
+                return {
+                    message,
+                    finishReason: finishReason ?? "stop",
+                    toolCalls,
+                };
+            }
+            const response = await client.chat.completions.create({
+                model: input.model,
+                messages: input
+                    .messages,
+                tools: input
+                    .tools,
+                tool_choice: "auto",
+                stream: false,
+                ...params,
+            });
+            const choice = response.choices[0];
+            const message = choice.message;
+            const normalizedMessage = normalizeMessage(message);
+            const toolCalls = message.tool_calls?.map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                args: safeJson(tc.function.arguments),
+            }));
+            return {
+                message: normalizedMessage,
+                finishReason: choice.finish_reason ??
+                    "stop",
+                toolCalls,
+                usage: response.usage
+                    ? {
+                        promptTokens: response.usage.prompt_tokens ?? 0,
+                        completionTokens: response.usage.completion_tokens ?? 0,
+                        totalTokens: response.usage.total_tokens ?? 0,
+                    }
+                    : undefined,
+            };
+        },
+    };
+}
+function safeJson(str) {
+    try {
+        const parsed = JSON.parse(str);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore bad tool args
+    }
+    return {};
+}

package/esm/gambit-core/src/render.d.ts

@@ -0,0 +1,51 @@
+import type { ModelMessage, ToolDefinition } from "@bolt-foundry/gambit-core/internal/types";
+export declare const logger: Console;
+export type RenderChatCompletionsRequest = {
+    model?: string;
+    messages: Array<{
+        role: "system" | "user" | "assistant" | "tool";
+        content: string | null | Array<string | {
+            text?: string;
+            type?: string;
+        }>;
+        name?: string;
+        tool_call_id?: string;
+        tool_calls?: ModelMessage["tool_calls"];
+    }>;
+    tools?: Array<ToolDefinition>;
+    stream?: boolean;
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    max_tokens?: number;
+    [key: string]: unknown;
+};
+export type RenderDeckOptions = {
+    deckPath: string;
+    request: RenderChatCompletionsRequest;
+    includeDeckSystem?: boolean;
+    includeDeckTools?: boolean;
+    warnOnSystemMismatch?: boolean;
+};
+export type RenderDeckResult = {
+    request: {
+        model: string;
+        messages: Array<ModelMessage>;
+        tools?: Array<ToolDefinition>;
+        stream?: boolean;
+        temperature?: number;
+        top_p?: number;
+        frequency_penalty?: number;
+        presence_penalty?: number;
+        max_tokens?: number;
+        [key: string]: unknown;
+    };
+    gambit: {
+        deckPath: string;
+        systemPrompt: string;
+        actionPathsByName: Record<string, string>;
+    };
+};
+export declare function renderDeck(opts: RenderDeckOptions): Promise<RenderDeckResult>;
+//# sourceMappingURL=render.d.ts.map

package/esm/gambit-core/src/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/gambit-core/src/render.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAe,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAE1G,eAAO,MAAM,MAAM,SAAU,CAAC;AAE9B,MAAM,MAAM,4BAA4B,GAAG;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;QAC/C,OAAO,EACH,MAAM,GACN,IAAI,GACJ,KAAK,CAAC,MAAM,GAAG;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACrD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;KACzC,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,4BAA4B,CAAC;IACtC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;QAC9B,KAAK,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAC3C,CAAC;CACH,CAAC;AA6JF,wBAAsB,UAAU,CAC9B,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0E3B"}

package/esm/gambit-core/src/render.js

@@ -0,0 +1,188 @@
+import { RESERVED_TOOL_PREFIX } from "@bolt-foundry/gambit-core/internal/constants";
+import { loadDeck } from "@bolt-foundry/gambit-core/internal/loader";
+import { assertZodSchema, toJsonSchema } from "./schema.js";
+export const logger = console;
+function normalizeContent(content) {
+    if (content === null)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return String(content);
+    return content
+        .map((c) => (typeof c === "string" ? c : (c.text ?? "")))
+        .join("");
+}
+function normalizeMessages(input) {
+    return input.map((m) => ({
+        role: m.role,
+        content: normalizeContent(m.content),
+        name: m.name,
+        tool_call_id: m.tool_call_id,
+        tool_calls: m.tool_calls && m.tool_calls.length > 0
+            ? m.tool_calls
+            : undefined,
+    }));
+}
+function deckSystemPrompt(deck) {
+    const parts = [];
+    const prompt = deck.body ?? deck.prompt;
+    if (prompt)
+        parts.push(prompt.trim());
+    if (!deck.inlineEmbeds) {
+        for (const card of deck.cards) {
+            if (card.body)
+                parts.push(card.body.trim());
+        }
+    }
+    return parts.join("\n\n").trim();
+}
+function shouldPrependDeckSystem(messages, systemPrompt) {
+    if (!systemPrompt)
+        return false;
+    if (!messages.length)
+        return true;
+    const hasExact = messages.some((m) => m.role === "system" && m.content === systemPrompt);
+    return !hasExact;
+}
+function warnIfSystemMismatch(args) {
+    if (!args.systemPrompt)
+        return;
+    const existing = args.provided.find((m) => m.role === "system");
+    if (!existing)
+        return;
+    if (existing.content === args.systemPrompt)
+        return;
+    logger.warn(`[gambit] renderDeck: request includes a system message that does not match the deck prompt (${args.deckPath})`);
+}
+function toolName(tool) {
+    return tool.function?.name ?? "";
+}
+function assertNoToolNameCollisions(args) {
+    if (!args.externalTools?.length)
+        return;
+    const gambit = new Set(args.gambitTools.map(toolName));
+    for (const t of args.externalTools) {
+        const name = toolName(t);
+        if (!name)
+            continue;
+        if (name.startsWith(RESERVED_TOOL_PREFIX)) {
+            throw new Error(`External tool name ${name} is reserved (prefix ${RESERVED_TOOL_PREFIX})`);
+        }
+        if (gambit.has(name)) {
+            throw new Error(`Tool name collision for ${name} between Gambit deck actions and external tools`);
+        }
+    }
+}
+async function buildDeckActionTools(deckPath) {
+    const deck = await loadDeck(deckPath);
+    const tools = [];
+    const actionPathsByName = {};
+    for (const action of deck.actionDecks) {
+        const child = await loadDeck(action.path, deck.path);
+        if (!child.inputSchema || !child.outputSchema) {
+            throw new Error(`Deck ${child.path} must declare inputSchema and outputSchema (non-root)`);
+        }
+        assertZodSchema(child.inputSchema, "inputSchema");
+        assertZodSchema(child.outputSchema, "outputSchema");
+        const params = toJsonSchema(child.inputSchema);
+        tools.push({
+            type: "function",
+            function: {
+                name: action.name,
+                description: action.description,
+                parameters: params,
+            },
+        });
+        actionPathsByName[action.name] = action.path;
+    }
+    return { tools, actionPathsByName };
+}
+function mergeModelParams(req, deckParams) {
+    const out = { ...req };
+    if (!deckParams)
+        return out;
+    if (out.model === undefined && deckParams.model)
+        out.model = deckParams.model;
+    if (out.temperature === undefined && deckParams.temperature !== undefined) {
+        out.temperature = deckParams.temperature;
+    }
+    if (out.top_p === undefined && deckParams.top_p !== undefined) {
+        out.top_p = deckParams.top_p;
+    }
+    if (out.frequency_penalty === undefined &&
+        deckParams.frequency_penalty !== undefined) {
+        out.frequency_penalty = deckParams.frequency_penalty;
+    }
+    if (out.presence_penalty === undefined &&
+        deckParams.presence_penalty !== undefined) {
+        out.presence_penalty = deckParams.presence_penalty;
+    }
+    if (out.max_tokens === undefined && deckParams.max_tokens !== undefined) {
+        out.max_tokens = deckParams.max_tokens;
+    }
+    return out;
+}
+export async function renderDeck(opts) {
+    const includeDeckSystem = opts.includeDeckSystem ?? true;
+    const includeDeckTools = opts.includeDeckTools ?? true;
+    const warnOnSystemMismatch = opts.warnOnSystemMismatch ?? true;
+    const deck = await loadDeck(opts.deckPath);
+    const systemPrompt = deckSystemPrompt(deck);
+    const mergedReq = mergeModelParams(opts.request, deck.modelParams);
+    const providedMessages = normalizeMessages(mergedReq.messages);
+    const messages = [];
+    if (includeDeckSystem) {
+        if (warnOnSystemMismatch) {
+            warnIfSystemMismatch({
+                provided: providedMessages,
+                systemPrompt,
+                deckPath: deck.path,
+            });
+        }
+        if (shouldPrependDeckSystem(providedMessages, systemPrompt)) {
+            messages.push({ role: "system", content: systemPrompt });
+        }
+    }
+    messages.push(...providedMessages);
+    let tools = undefined;
+    let actionPathsByName = {};
+    if (includeDeckTools) {
+        const built = await buildDeckActionTools(deck.path);
+        actionPathsByName = built.actionPathsByName;
+        assertNoToolNameCollisions({
+            gambitTools: built.tools,
+            externalTools: mergedReq.tools,
+        });
+        tools = mergedReq.tools?.length
+            ? [...built.tools, ...mergedReq.tools]
+            : built.tools;
+    }
+    else if (mergedReq.tools?.length) {
+        for (const t of mergedReq.tools) {
+            const name = toolName(t);
+            if (name.startsWith(RESERVED_TOOL_PREFIX)) {
+                throw new Error(`External tool name ${name} is reserved (prefix ${RESERVED_TOOL_PREFIX})`);
+            }
+        }
+        tools = mergedReq.tools;
+    }
+    const model = String(mergedReq.model ?? "").trim();
+    if (!model) {
+        throw new Error(`renderDeck requires request.model (or deck.modelParams.model): ${deck.path}`);
+    }
+    const { messages: _m, tools: _t, ...rest } = mergedReq;
+    return {
+        request: {
+            ...rest,
+            model,
+            messages,
+            tools: tools && tools.length ? tools : undefined,
+        },
+        gambit: {
+            deckPath: deck.path,
+            systemPrompt,
+            actionPathsByName,
+        },
+    };
+}

package/esm/gambit-core/src/schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { JSONValue } from "@bolt-foundry/gambit-core/internal/types";
+import type { ZodTypeAny } from "zod";
+export declare function validateWithSchema<T>(schema: z.ZodType<T>, value: unknown): T;
+export declare function toJsonSchema(schema: z.ZodTypeAny): Record<string, JSONValue>;
+export declare function assertZodSchema(value: unknown, label: string): asserts value is z.ZodTypeAny;
+export declare function mergeZodObjects(base: ZodTypeAny | undefined, fragment: ZodTypeAny | undefined): ZodTypeAny | undefined;
+//# sourceMappingURL=schema.d.ts.map

package/esm/gambit-core/src/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/gambit-core/src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,KAAK,EAA0B,UAAU,EAAE,MAAM,KAAK,CAAC;AAE9D,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,KAAK,EAAE,OAAO,GACb,CAAC,CAUH;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAO5E;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,UAAU,CAQ/B;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,QAAQ,EAAE,UAAU,GAAG,SAAS,GAC/B,UAAU,GAAG,SAAS,CAOxB"}

package/esm/gambit-core/src/schema.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+export function validateWithSchema(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        const issue = result.error.issues?.[0];
+        const message = issue
+            ? `${issue.path.join(".") || "(root)"}: ${issue.message}`
+            : result.error.message;
+        throw new Error(`Schema validation failed: ${message}`);
+    }
+    return result.data;
+}
+export function toJsonSchema(schema) {
+    const converted = zodToJsonSchema(schema, { $refStrategy: "none" });
+    if (converted && typeof converted === "object") {
+        return converted;
+    }
+    // Fallback to permissive object if conversion fails
+    return { type: "object" };
+}
+export function assertZodSchema(value, label) {
+    if (!value || typeof value !== "object") {
+        throw new Error(`${label} must be a Zod schema`);
+    }
+    // Duck-typing: check for safeParse
+    if (typeof value.safeParse !== "function") {
+        throw new Error(`${label} must be a Zod schema (missing safeParse)`);
+    }
+}
+export function mergeZodObjects(base, fragment) {
+    if (!fragment)
+        return base;
+    if (!base)
+        return fragment;
+    const baseObj = asZodObject(base, "base schema");
+    const fragObj = asZodObject(fragment, "fragment schema");
+    const mergedShape = { ...fragObj.shape, ...baseObj.shape };
+    return z.object(mergedShape);
+}
+function asZodObject(schema, label) {
+    if (schema instanceof z.ZodObject)
+        return schema;
+    throw new Error(`${label} must be a Zod object schema to merge fragments`);
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bolt-foundry/gambit",
+  "version": "0.5.3-dev.1",
+  "description": "Agent harness framework for building, running, and verifying LLM workflows in Markdown and code.",
+  "homepage": "https://github.com/bolt-foundry/gambit",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bolt-foundry/gambit.git"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/bolt-foundry/gambit/issues"
+  },
+  "main": "./script/gambit/mod.js",
+  "module": "./esm/gambit/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/gambit/mod.js",
+      "require": "./script/gambit/mod.js"
+    }
+  },
+  "dependencies": {
+    "@bolt-foundry/gambit-core": "^0.5.3-dev.1",
+    "openai": "^4.78.1",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.0",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_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/script/_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/script/_dnt.polyfills.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/_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/script/_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/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.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/script/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/script/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/script/deps/jsr.io/@std/internal/1.0.12/_os.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWindows = checkWindows;
+// Copyright 2018-2025 the Deno authors. MIT license.
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+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/script/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