@ganju/utils 0.0.1

package/dist/crypto.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'hono';
+export declare const getCredentialEncryptionKey: (c: Context) => string;
+export declare const encryptString: (plaintext: string, rawKey: string) => string;
+export declare const decryptString: (value: string, rawKey: string) => string;
+export declare const sha256Hex: (input: string) => Promise<string>;
+/**
+ * SHA-256 as unpadded base64url — the format `@better-auth/oauth-provider`
+ * stores hashed client secrets in. Anything comparing against a stored
+ * `oauth_client.client_secret` has to hash the candidate exactly this way.
+ */
+export declare const sha256Base64Url: (input: string) => Promise<string>;
+export declare const hmacSha256Hex: (key: string, message: string) => Promise<string>;
+export declare const timingSafeEqual: (a: string, b: string) => boolean;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAU/B,eAAO,MAAM,0BAA0B,GAAI,GAAG,OAAO,WAMpD,CAAC;AAYF,eAAO,MAAM,aAAa,GAAI,WAAW,MAAM,EAAE,QAAQ,MAAM,WAS9D,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,WAS1D,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,OAAO,MAAM,oBAW5C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAU,OAAO,MAAM,oBASlD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,KAAK,MAAM,EAAE,SAAS,MAAM,oBAmB/D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,YAOnD,CAAC"}

package/dist/crypto.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timingSafeEqual = exports.hmacSha256Hex = exports.sha256Base64Url = exports.sha256Hex = exports.decryptString = exports.encryptString = exports.getCredentialEncryptionKey = void 0;
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const getEnv_1 = require("./getEnv");
+const base64_1 = require("./base64");
+const PREFIX = 'enc:v1:';
+const NONCE_BYTES = 24;
+const KEY_BYTES = 32;
+const KEY_ENV = 'CRYPTO_SECRET';
+const getCredentialEncryptionKey = (c) => {
+    const rawKey = (0, getEnv_1.getEnv)(c, KEY_ENV);
+    if (!rawKey) {
+        throw new Error(`Missing env: ${KEY_ENV}`);
+    }
+    return rawKey;
+};
+exports.getCredentialEncryptionKey = getCredentialEncryptionKey;
+const loadKey = (rawKey) => {
+    const bytes = (0, base64_1.base64ToBytes)(rawKey);
+    if (bytes.length !== KEY_BYTES) {
+        throw new Error(`CRYPTO_SECRET must decode to ${KEY_BYTES} bytes (got ${bytes.length})`);
+    }
+    return bytes;
+};
+const encryptString = (plaintext, rawKey) => {
+    const key = loadKey(rawKey);
+    const nonce = crypto.getRandomValues(new Uint8Array(NONCE_BYTES));
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce);
+    const ciphertext = cipher.encrypt(new TextEncoder().encode(plaintext));
+    const bundle = new Uint8Array(nonce.length + ciphertext.length);
+    bundle.set(nonce, 0);
+    bundle.set(ciphertext, nonce.length);
+    return `${PREFIX}${(0, base64_1.bytesToBase64)(bundle)}`;
+};
+exports.encryptString = encryptString;
+const decryptString = (value, rawKey) => {
+    if (!value.startsWith(PREFIX))
+        return value;
+    const bundle = (0, base64_1.base64ToBytes)(value.slice(PREFIX.length));
+    const nonce = bundle.slice(0, NONCE_BYTES);
+    const ciphertext = bundle.slice(NONCE_BYTES);
+    const key = loadKey(rawKey);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce);
+    const plaintext = cipher.decrypt(ciphertext);
+    return new TextDecoder().decode(plaintext);
+};
+exports.decryptString = decryptString;
+const sha256Hex = async (input) => {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+    const bytes = new Uint8Array(digest);
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+};
+exports.sha256Hex = sha256Hex;
+/**
+ * SHA-256 as unpadded base64url — the format `@better-auth/oauth-provider`
+ * stores hashed client secrets in. Anything comparing against a stored
+ * `oauth_client.client_secret` has to hash the candidate exactly this way.
+ */
+const sha256Base64Url = async (input) => {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+    const bytes = new Uint8Array(digest);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+};
+exports.sha256Base64Url = sha256Base64Url;
+const hmacSha256Hex = async (key, message) => {
+    const cryptoKey = await crypto.subtle.importKey('raw', new TextEncoder().encode(key), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const signature = await crypto.subtle.sign('HMAC', cryptoKey, new TextEncoder().encode(message));
+    const bytes = new Uint8Array(signature);
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+};
+exports.hmacSha256Hex = hmacSha256Hex;
+const timingSafeEqual = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) {
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return diff === 0;
+};
+exports.timingSafeEqual = timingSafeEqual;

package/dist/customCodeProject.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A dashboard-authored script is a set of files, not one file.
+ *
+ * The deploy path already uploads more than one module — the SDK travels beside
+ * every script as `ganju-sdk.js` — so the runtime has never been the thing
+ * holding this to a single file. What was single was the storage: one R2 object
+ * holding one module's text.
+ *
+ * So the object becomes an envelope. `sourceKind: 'editor'` bytes are JSON of
+ * this shape; `'bundle'` bytes stay exactly what the CLI compiled, because a
+ * bundle IS one module and wrapping it would mean the stored bytes are no longer
+ * the thing that runs. `decodeProject` tells the two apart by reading the marker,
+ * which is why there is a marker rather than a bare `{ files }` — arbitrary
+ * minified JS never parses as JSON, but a bundle that happens to be a JSON
+ * module would, and guessing is not a thing to do with someone's deploy.
+ */
+export declare const CUSTOM_CODE_PROJECT_MARKER = "ganjuProject";
+export interface CustomCodeProject {
+    [CUSTOM_CODE_PROJECT_MARKER]: 1;
+    files: Record<string, string>;
+}
+export declare const encodeProject: (files: Record<string, string>) => string;
+/**
+ * Read stored bytes back as a set of files, or `null` when they are a single
+ * module — the CLI's bundle, and every editor version written before folders
+ * existed.
+ */
+export declare const decodeProject: (text: string) => Record<string, string> | null;
+/**
+ * Why one path is not a legal file in a script — the rule that refused it, and
+ * what it needs to say so.
+ *
+ * A code rather than a sentence, because there are two readers. The upload path
+ * throws it as English, which is what `error_log` has always held; the
+ * dashboard's file explorer renders it in whatever language the person is
+ * reading, at the keystroke. Returning prose would have forced the explorer to
+ * either show English or keep a second copy of these rules — and a second copy
+ * is how the two surfaces come to disagree about what a legal name is.
+ */
+export type ProjectPathIssue = {
+    code: 'required';
+} | {
+    code: 'tooLong';
+    path: string;
+    max: number;
+} | {
+    code: 'charset';
+    path: string;
+} | {
+    code: 'dots';
+    path: string;
+} | {
+    code: 'extension';
+    path: string;
+} | {
+    code: 'reserved';
+    path: string;
+} | {
+    code: 'taken';
+    path: string;
+};
+/**
+ * Check ONE path against every rule a stored file has to satisfy.
+ *
+ * Split out of the set-level check below so the dashboard's file explorer can
+ * apply the identical rules as someone types a name, rather than letting them
+ * finish, click deploy, and read the same sentence back as a 400. There is one
+ * definition of what a legal path is, and both surfaces call it.
+ *
+ * `taken` is the paths already in the project, compared case-insensitively —
+ * pass the file being renamed's own path in it and the rename reports a
+ * collision with itself, so callers exclude it.
+ */
+export declare const projectPathIssue: (path: string, taken?: Iterable<string>) => ProjectPathIssue | null;
+/**
+ * The same check, rendered in English — what the upload path throws and what
+ * lands in `error_log`. Messages carry a word `matchStatus` recognises, so they
+ * land as 400s rather than opaque 500s.
+ */
+export declare const validateProjectPath: (path: string, taken?: Iterable<string>) => string | null;
+/**
+ * Check a set of files before anything is stored or deployed.
+ *
+ * Paths are the module names the Workers upload API receives, and a script's
+ * imports resolve against them — so a path that escapes the root, collides with
+ * the SDK's own module, or arrives twice under different spellings is a deploy
+ * that fails in the runtime rather than here. Messages carry a word `matchStatus`
+ * recognises, so these land as 400s rather than opaque 500s.
+ */
+export declare const validateProjectFiles: (files: Record<string, string>) => void;
+//# sourceMappingURL=customCodeProject.d.ts.map

package/dist/customCodeProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customCodeProject.d.ts","sourceRoot":"","sources":["../src/customCodeProject.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,iBAAiB,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MACF,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAiBrE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,MAAM,EACZ,QAAO,QAAQ,CAAC,MAAM,CAAM,KAC3B,gBAAgB,GAAG,IA8BrB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,MAAM,EACZ,QAAO,QAAQ,CAAC,MAAM,CAAM,KAC3B,MAAM,GAAG,IAoBX,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,IAuBpE,CAAC"}

package/dist/customCodeProject.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProjectFiles = exports.validateProjectPath = exports.projectPathIssue = exports.decodeProject = exports.encodeProject = exports.CUSTOM_CODE_PROJECT_MARKER = void 0;
+const constants_1 = require("./constants");
+/**
+ * A dashboard-authored script is a set of files, not one file.
+ *
+ * The deploy path already uploads more than one module — the SDK travels beside
+ * every script as `ganju-sdk.js` — so the runtime has never been the thing
+ * holding this to a single file. What was single was the storage: one R2 object
+ * holding one module's text.
+ *
+ * So the object becomes an envelope. `sourceKind: 'editor'` bytes are JSON of
+ * this shape; `'bundle'` bytes stay exactly what the CLI compiled, because a
+ * bundle IS one module and wrapping it would mean the stored bytes are no longer
+ * the thing that runs. `decodeProject` tells the two apart by reading the marker,
+ * which is why there is a marker rather than a bare `{ files }` — arbitrary
+ * minified JS never parses as JSON, but a bundle that happens to be a JSON
+ * module would, and guessing is not a thing to do with someone's deploy.
+ */
+exports.CUSTOM_CODE_PROJECT_MARKER = 'ganjuProject';
+const encodeProject = (files) => JSON.stringify({ [exports.CUSTOM_CODE_PROJECT_MARKER]: 1, files });
+exports.encodeProject = encodeProject;
+/**
+ * Read stored bytes back as a set of files, or `null` when they are a single
+ * module — the CLI's bundle, and every editor version written before folders
+ * existed.
+ */
+const decodeProject = (text) => {
+    if (!text.trimStart().startsWith('{'))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const envelope = parsed;
+    if (envelope[exports.CUSTOM_CODE_PROJECT_MARKER] !== 1)
+        return null;
+    if (!envelope.files || typeof envelope.files !== 'object')
+        return null;
+    const files = {};
+    for (const [path, content] of Object.entries(envelope.files)) {
+        if (typeof content === 'string')
+            files[path] = content;
+    }
+    return files;
+};
+exports.decodeProject = decodeProject;
+/**
+ * Check ONE path against every rule a stored file has to satisfy.
+ *
+ * Split out of the set-level check below so the dashboard's file explorer can
+ * apply the identical rules as someone types a name, rather than letting them
+ * finish, click deploy, and read the same sentence back as a 400. There is one
+ * definition of what a legal path is, and both surfaces call it.
+ *
+ * `taken` is the paths already in the project, compared case-insensitively —
+ * pass the file being renamed's own path in it and the rename reports a
+ * collision with itself, so callers exclude it.
+ */
+const projectPathIssue = (path, taken = []) => {
+    if (!path)
+        return { code: 'required' };
+    if (path.length > constants_1.constants.CUSTOM_CODE_MAX_FILE_PATH) {
+        return {
+            code: 'tooLong',
+            path,
+            max: constants_1.constants.CUSTOM_CODE_MAX_FILE_PATH
+        };
+    }
+    if (!/^[a-zA-Z0-9._-]+(\/[a-zA-Z0-9._-]+)*$/.test(path)) {
+        return { code: 'charset', path };
+    }
+    if (path.split('/').some(segment => segment === '.' || segment === '..')) {
+        return { code: 'dots', path };
+    }
+    if (!path.endsWith('.js')) {
+        return { code: 'extension', path };
+    }
+    if (path === constants_1.constants.CUSTOM_CODE_SDK_MODULE) {
+        return { code: 'reserved', path };
+    }
+    // Case-insensitively, because two files differing only in case are one file
+    // on the machine of whoever downloads them next.
+    const lower = path.toLowerCase();
+    for (const other of taken) {
+        if (other.toLowerCase() === lower) {
+            return { code: 'taken', path };
+        }
+    }
+    return null;
+};
+exports.projectPathIssue = projectPathIssue;
+/**
+ * The same check, rendered in English — what the upload path throws and what
+ * lands in `error_log`. Messages carry a word `matchStatus` recognises, so they
+ * land as 400s rather than opaque 500s.
+ */
+const validateProjectPath = (path, taken = []) => {
+    const issue = (0, exports.projectPathIssue)(path, taken);
+    if (!issue)
+        return null;
+    switch (issue.code) {
+        case 'required':
+            return 'A name is required';
+        case 'tooLong':
+            return `The path "${issue.path}" exceeds ${issue.max} characters`;
+        case 'charset':
+            return `Invalid file path "${issue.path}" — letters, digits, dot, dash, underscore and / only, with no leading or trailing slash`;
+        case 'dots':
+            return `Invalid file path "${issue.path}" — . and .. are not allowed`;
+        case 'extension':
+            return `Invalid file path "${issue.path}" — every file must end in .js, since it is deployed as a module exactly as written`;
+        case 'reserved':
+            return `Invalid file path "${issue.path}" — that name belongs to the SDK, which is attached to every deploy`;
+        case 'taken':
+            return `Invalid file path "${issue.path}" — it is already in use`;
+    }
+};
+exports.validateProjectPath = validateProjectPath;
+/**
+ * Check a set of files before anything is stored or deployed.
+ *
+ * Paths are the module names the Workers upload API receives, and a script's
+ * imports resolve against them — so a path that escapes the root, collides with
+ * the SDK's own module, or arrives twice under different spellings is a deploy
+ * that fails in the runtime rather than here. Messages carry a word `matchStatus`
+ * recognises, so these land as 400s rather than opaque 500s.
+ */
+const validateProjectFiles = (files) => {
+    const paths = Object.keys(files);
+    if (paths.length === 0) {
+        throw new Error('At least one file is required');
+    }
+    if (paths.length > constants_1.constants.CUSTOM_CODE_MAX_FILES) {
+        throw new Error(`The project exceeds the ${constants_1.constants.CUSTOM_CODE_MAX_FILES}-file limit`);
+    }
+    if (!files[constants_1.constants.CUSTOM_CODE_MAIN_MODULE]) {
+        throw new Error(`A file named ${constants_1.constants.CUSTOM_CODE_MAIN_MODULE} is required — it is the module the dispatcher calls`);
+    }
+    const seen = new Set();
+    for (const path of paths) {
+        const problem = (0, exports.validateProjectPath)(path, seen);
+        if (problem)
+            throw new Error(problem);
+        seen.add(path.toLowerCase());
+    }
+};
+exports.validateProjectFiles = validateProjectFiles;

package/dist/customCodeToken.d.ts

@@ -0,0 +1,41 @@
+export interface CustomCodeTokenPayload {
+    v: string;
+    artifactId: string;
+    versionId: string;
+    iat: number;
+    preview?: boolean;
+    exp?: number;
+}
+/**
+ * Mint a tool token for one artifact + version. Called by the publish pipeline
+ * immediately before upload; the result is written as a `secret_text` binding so
+ * it never appears in the bundle the user can read back.
+ */
+export declare const mintCustomCodeToken: (payload: Omit<CustomCodeTokenPayload, "v" | "iat" | "exp"> & {
+    ttlMs?: number;
+}, secret: string, issuedAt?: number) => Promise<string>;
+/**
+ * Verify a tool token and return its payload, or null when it is malformed, of
+ * an unknown format version, or not signed by this deployment's secret.
+ *
+ * Returning null rather than throwing keeps the broker's failure path uniform:
+ * every rejection is the same 401, so a caller learns nothing about which check
+ * failed.
+ */
+export declare const verifyCustomCodeToken: (token: string, secret: string, now?: number) => Promise<CustomCodeTokenPayload | null>;
+/**
+ * The dispatch-namespace script name for an artifact: `artifact_<id>`.
+ *
+ * The id, never the slug — slugs are user-editable and a rename would orphan the
+ * deployed script while the database still pointed at a live version.
+ */
+export declare const customCodeScriptName: (artifactId: string) => string;
+/**
+ * The script name a test run deploys into: `artifact_<id>_preview`.
+ *
+ * A second script rather than a second version of the live one, because a test
+ * must not be able to disturb what MCP clients are being served — and the only
+ * way to be certain of that is for it to run under a name nothing dispatches to.
+ */
+export declare const customCodePreviewScriptName: (artifactId: string) => string;
+//# sourceMappingURL=customCodeToken.d.ts.map

package/dist/customCodeToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customCodeToken.d.ts","sourceRoot":"","sources":["../src/customCodeToken.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,sBAAsB;IAGrC,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IAGnB,SAAS,EAAE,MAAM,CAAC;IAIlB,GAAG,EAAE,MAAM,CAAC;IAOZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAGlB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AA0BD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,IAAI,CAAC,sBAAsB,EAAE,GAAG,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,EACD,QAAQ,MAAM,EACd,WAAU,MAAmB,KAC5B,OAAO,CAAC,MAAM,CAmBhB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,MAAM,MAAM,KACX,OAAO,CAAC,sBAAsB,GAAG,IAAI,CA+DvC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,YAAY,MAAM,KAAG,MACE,CAAC;AAE7D;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GAAI,YAAY,MAAM,KAAG,MACoB,CAAC"}

package/dist/customCodeToken.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customCodePreviewScriptName = exports.customCodeScriptName = exports.verifyCustomCodeToken = exports.mintCustomCodeToken = void 0;
+const base64_1 = require("./base64");
+const constants_1 = require("./constants");
+const encoder = new TextEncoder();
+const importKey = (secret) => crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign', 'verify']);
+const signPayload = async (encodedPayload, secret) => {
+    const key = await importKey(secret);
+    const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(encodedPayload));
+    return (0, base64_1.toBase64Url)((0, base64_1.bytesToBase64)(new Uint8Array(signature)));
+};
+/**
+ * Mint a tool token for one artifact + version. Called by the publish pipeline
+ * immediately before upload; the result is written as a `secret_text` binding so
+ * it never appears in the bundle the user can read back.
+ */
+const mintCustomCodeToken = async (payload, secret, issuedAt = Date.now()) => {
+    const body = {
+        v: constants_1.constants.CUSTOM_CODE_TOKEN_VERSION,
+        artifactId: payload.artifactId,
+        versionId: payload.versionId,
+        iat: Math.floor(issuedAt / 1000),
+        ...(payload.preview ? { preview: true } : {}),
+        // Rounded up, not down: `exp` is in seconds, and truncating would make a
+        // stated ten-minute lifetime end up to a second early. A ceiling means the
+        // TTL is a floor, which is what the caller asked for.
+        ...(payload.ttlMs
+            ? { exp: Math.ceil((issuedAt + payload.ttlMs) / 1000) }
+            : {})
+    };
+    const encodedPayload = (0, base64_1.toBase64Url)((0, base64_1.bytesToBase64)(encoder.encode(JSON.stringify(body))));
+    const signature = await signPayload(encodedPayload, secret);
+    return `${encodedPayload}.${signature}`;
+};
+exports.mintCustomCodeToken = mintCustomCodeToken;
+/**
+ * Verify a tool token and return its payload, or null when it is malformed, of
+ * an unknown format version, or not signed by this deployment's secret.
+ *
+ * Returning null rather than throwing keeps the broker's failure path uniform:
+ * every rejection is the same 401, so a caller learns nothing about which check
+ * failed.
+ */
+const verifyCustomCodeToken = async (token, secret, now) => {
+    const separator = token.lastIndexOf('.');
+    if (separator <= 0)
+        return null;
+    const encodedPayload = token.slice(0, separator);
+    const signature = token.slice(separator + 1);
+    const key = await importKey(secret);
+    let valid;
+    try {
+        // Copied into a fresh view so its backing store is a plain ArrayBuffer —
+        // base64ToBytes is typed against ArrayBufferLike, which subtle.verify's
+        // BufferSource parameter does not accept.
+        const signatureBytes = new Uint8Array((0, base64_1.base64ToBytes)((0, base64_1.fromBase64Url)(signature)));
+        valid = await crypto.subtle.verify('HMAC', key, signatureBytes, encoder.encode(encodedPayload));
+    }
+    catch {
+        return null;
+    }
+    if (!valid)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode((0, base64_1.base64ToBytes)((0, base64_1.fromBase64Url)(encodedPayload))));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const candidate = parsed;
+    if (candidate.v !== constants_1.constants.CUSTOM_CODE_TOKEN_VERSION)
+        return null;
+    if (typeof candidate.artifactId !== 'string' || !candidate.artifactId) {
+        return null;
+    }
+    if (typeof candidate.versionId !== 'string' || !candidate.versionId) {
+        return null;
+    }
+    // Checked here rather than in the broker so every caller gets it: a token past
+    // its expiry is as good as unsigned.
+    if (typeof candidate.exp === 'number' &&
+        candidate.exp * 1000 <= (now ?? Date.now())) {
+        return null;
+    }
+    return {
+        v: candidate.v,
+        artifactId: candidate.artifactId,
+        versionId: candidate.versionId,
+        iat: typeof candidate.iat === 'number' ? candidate.iat : 0,
+        ...(candidate.preview === true ? { preview: true } : {}),
+        ...(typeof candidate.exp === 'number' ? { exp: candidate.exp } : {})
+    };
+};
+exports.verifyCustomCodeToken = verifyCustomCodeToken;
+/**
+ * The dispatch-namespace script name for an artifact: `artifact_<id>`.
+ *
+ * The id, never the slug — slugs are user-editable and a rename would orphan the
+ * deployed script while the database still pointed at a live version.
+ */
+const customCodeScriptName = (artifactId) => `${constants_1.constants.CUSTOM_CODE_SCRIPT_NAME_PREFIX}${artifactId}`;
+exports.customCodeScriptName = customCodeScriptName;
+/**
+ * The script name a test run deploys into: `artifact_<id>_preview`.
+ *
+ * A second script rather than a second version of the live one, because a test
+ * must not be able to disturb what MCP clients are being served — and the only
+ * way to be certain of that is for it to run under a name nothing dispatches to.
+ */
+const customCodePreviewScriptName = (artifactId) => `${(0, exports.customCodeScriptName)(artifactId)}${constants_1.constants.CUSTOM_CODE_PREVIEW_SCRIPT_SUFFIX}`;
+exports.customCodePreviewScriptName = customCodePreviewScriptName;

package/dist/deadline.d.ts

@@ -0,0 +1,6 @@
+export declare class DeadlineError extends Error {
+    constructor(ms: number);
+}
+export declare const withDeadline: <T>(work: Promise<T>, ms: number) => Promise<T>;
+export declare const isDeadlineError: (error: unknown) => boolean;
+//# sourceMappingURL=deadline.d.ts.map

package/dist/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../src/deadline.ts"],"names":[],"mappings":"AAeA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,EAAE,EAAE,MAAM;CAMvB;AAED,eAAO,MAAM,YAAY,GAAU,CAAC,EAClC,MAAM,OAAO,CAAC,CAAC,CAAC,EAChB,IAAI,MAAM,KACT,OAAO,CAAC,CAAC,CAYX,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,OACQ,CAAC"}

package/dist/deadline.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeadlineError = exports.withDeadline = exports.DeadlineError = void 0;
+// Bound how long we wait for a dispatched user script, without handing the
+// binding an AbortSignal.
+//
+// The obvious version — `fetch(url, { signal })` on a Fetcher from a dispatch
+// namespace — works when the binding is in the same process and fails when it is
+// not: `AbortSignal serialization is not enabled`. A local `wrangler dev` proxies
+// the dispatch namespace to the remote account, so every test run and every tool
+// call raised that instead of running, while the deployed Worker was fine. A
+// timeout that only works in production is worse than no timeout, because it
+// breaks the environment where people are actually writing the code.
+//
+// What is lost by racing instead of aborting: the isolate keeps running after we
+// stop waiting for it. That is what the per-script `limits.cpu_ms` ceiling is
+// for, and this deadline was never a cost control — it bounds how long a person
+// watches a spinner.
+class DeadlineError extends Error {
+    constructor(ms) {
+        super(`Timed out after ${ms}ms`);
+        // Named the way an aborted fetch is, so a call site that already branches on
+        // the name keeps reading the same way.
+        this.name = 'TimeoutError';
+    }
+}
+exports.DeadlineError = DeadlineError;
+const withDeadline = async (work, ms) => {
+    let timer;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new DeadlineError(ms)), ms);
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+};
+exports.withDeadline = withDeadline;
+const isDeadlineError = (error) => error instanceof Error && error.name === 'TimeoutError';
+exports.isDeadlineError = isDeadlineError;

package/dist/discordSend.d.ts

@@ -0,0 +1,25 @@
+export interface DiscordSendRequest {
+    botToken: string;
+    channelId: string;
+    replyToMessageId?: string;
+    content?: string;
+}
+export interface DiscordSendResponse {
+    ok: boolean;
+    id?: string;
+    error?: string;
+}
+export interface DiscordSendRemoteResourceRequest {
+    discord: DiscordSendRequest;
+    remote: {
+        url: string;
+        transport: string;
+        authHeader?: {
+            name: string;
+            value: string;
+        } | null;
+        uri: string;
+        timeoutMs: number;
+    };
+}
+//# sourceMappingURL=discordSend.d.ts.map

package/dist/discordSend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discordSend.d.ts","sourceRoot":"","sources":["../src/discordSend.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IAGjB,SAAS,EAAE,MAAM,CAAC;IAElB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAG1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAOD,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,kBAAkB,CAAC;IAC5B,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAElB,UAAU,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QACpD,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH"}

package/dist/discordSend.js

@@ -0,0 +1,8 @@
+"use strict";
+// Wire protocol shared between the worker (which constructs the request) and the
+// resource-handler container (which parses it and calls the Discord API). The
+// worker sends a multipart/form-data POST with one `metadata` field (JSON
+// matching DiscordSendRequest) and exactly one `file` field (binary). Discord
+// uploads a file by posting a `payload_json` + `files[0]` multipart to
+// POST /channels/{channelId}/messages.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/embeddable.d.ts

@@ -0,0 +1,2 @@
+export declare const isEmbeddableMimeType: (mimeType: string) => boolean;
+//# sourceMappingURL=embeddable.d.ts.map

package/dist/embeddable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddable.d.ts","sourceRoot":"","sources":["../src/embeddable.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,KAAG,OACmB,CAAC"}

package/dist/embeddable.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmbeddableMimeType = void 0;
+const constants_1 = require("./constants");
+const isEmbeddableMimeType = (mimeType) => constants_1.constants.EMBEDDABLE_MIME_TYPES.includes(mimeType);
+exports.isEmbeddableMimeType = isEmbeddableMimeType;

package/dist/exposedResource.d.ts

@@ -0,0 +1,6 @@
+export interface ExposableResource {
+    sourceType?: string | null;
+    parentResourceId?: string | null;
+}
+export declare const isExposedResource: (resource: ExposableResource) => boolean;
+//# sourceMappingURL=exposedResource.d.ts.map

package/dist/exposedResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposedResource.d.ts","sourceRoot":"","sources":["../src/exposedResource.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,eAAO,MAAM,iBAAiB,GAAI,UAAU,iBAAiB,KAAG,OAgB/D,CAAC"}