@kuratchi/js 0.0.21 → 0.0.23

package/dist/compiler/desktop-manifest.js

@@ -0,0 +1,175 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function buildDesktopManifest(opts) {
+    const { projectDir, workerFile, desktopConfig, ormDatabases } = opts;
+    if (!desktopConfig)
+        return null;
+    const wranglerConfig = readDesktopWranglerConfig(projectDir);
+    const projectName = path.basename(projectDir);
+    const appName = desktopConfig.appName ?? projectName;
+    const appId = desktopConfig.appId ?? `dev.kuratchi.${projectName.replace(/[^a-z0-9]+/gi, '-').toLowerCase()}`;
+    const assetsRoot = resolveAssetsRoot(projectDir);
+    const requestedRemoteBindings = desktopConfig.remoteBindings.length > 0
+        ? desktopConfig.remoteBindings
+        : ormDatabases
+            .filter((entry) => entry.type === 'd1' && entry.remote)
+            .map((entry) => ({ binding: entry.binding, type: 'd1', remote: true }));
+    const remoteBindings = requestedRemoteBindings.map((binding) => {
+        if (binding.type === 'd1') {
+            const wranglerBinding = wranglerConfig.d1Databases.find((entry) => entry.binding === binding.binding && entry.remote);
+            if (!wranglerBinding) {
+                throw new Error(`Desktop manifest could not resolve remote D1 binding "${binding.binding}" from wrangler.jsonc.`);
+            }
+            return {
+                binding: binding.binding,
+                type: 'd1',
+                remote: true,
+                databaseId: wranglerBinding.databaseId,
+                databaseName: wranglerBinding.databaseName,
+            };
+        }
+        const wranglerBinding = wranglerConfig.r2Buckets.find((entry) => entry.binding === binding.binding && entry.remote);
+        if (!wranglerBinding) {
+            throw new Error(`Desktop manifest could not resolve remote R2 binding "${binding.binding}" from wrangler.jsonc.`);
+        }
+        return {
+            binding: binding.binding,
+            type: 'r2',
+            remote: true,
+            bucketName: wranglerBinding.bucketName,
+        };
+    });
+    return {
+        formatVersion: 1,
+        generatedAt: new Date().toISOString(),
+        projectDir,
+        app: {
+            name: appName,
+            id: appId,
+            initialPath: desktopConfig.initialPath || '/',
+            window: {
+                title: desktopConfig.windowTitle ?? appName,
+                width: desktopConfig.windowWidth,
+                height: desktopConfig.windowHeight,
+            },
+        },
+        runtime: {
+            workerEntrypoint: workerFile,
+            assetsRoot,
+            compatibilityDate: wranglerConfig.compatibilityDate,
+            compatibilityFlags: wranglerConfig.compatibilityFlags,
+            cloudflareAccountId: wranglerConfig.cloudflareAccountId,
+        },
+        bindings: {
+            desktop: {
+                notifications: desktopConfig.bindings.notifications,
+                files: desktopConfig.bindings.files,
+            },
+            remote: remoteBindings,
+        },
+    };
+}
+export function writeDesktopManifest(projectDir, manifest) {
+    const outFile = path.join(projectDir, '.kuratchi', 'desktop.manifest.json');
+    const next = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (fs.existsSync(outFile)) {
+        const current = fs.readFileSync(outFile, 'utf-8');
+        if (current === next)
+            return outFile;
+    }
+    fs.writeFileSync(outFile, next, 'utf-8');
+    return outFile;
+}
+function resolveAssetsRoot(projectDir) {
+    const publicDir = path.join(projectDir, '.kuratchi', 'public');
+    if (fs.existsSync(publicDir))
+        return publicDir;
+    const srcAssets = path.join(projectDir, 'src', 'assets');
+    if (fs.existsSync(srcAssets))
+        return srcAssets;
+    return null;
+}
+function readDesktopWranglerConfig(projectDir) {
+    const configPath = ['wrangler.jsonc', 'wrangler.json']
+        .map((name) => path.join(projectDir, name))
+        .find((candidate) => fs.existsSync(candidate));
+    if (!configPath) {
+        throw new Error('Desktop runtime requires wrangler.jsonc or wrangler.json for compatibility settings and remote bindings.');
+    }
+    const rawConfig = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(stripJsonComments(rawConfig));
+    if (!parsed.compatibility_date) {
+        throw new Error(`Missing compatibility_date in ${path.basename(configPath)}.`);
+    }
+    return {
+        compatibilityDate: parsed.compatibility_date,
+        compatibilityFlags: Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [],
+        cloudflareAccountId: typeof parsed.account_id === 'string' && parsed.account_id.trim().length > 0
+            ? parsed.account_id.trim()
+            : null,
+        d1Databases: Array.isArray(parsed.d1_databases)
+            ? parsed.d1_databases
+                .filter((entry) => entry.binding && entry.database_id)
+                .map((entry) => ({
+                binding: entry.binding,
+                databaseId: entry.database_id,
+                databaseName: entry.database_name ?? null,
+                remote: entry.remote !== false,
+            }))
+            : [],
+        r2Buckets: Array.isArray(parsed.r2_buckets)
+            ? parsed.r2_buckets
+                .filter((entry) => entry.binding && entry.bucket_name)
+                .map((entry) => ({
+                binding: entry.binding,
+                bucketName: entry.bucket_name,
+                remote: entry.remote !== false,
+            }))
+            : [],
+    };
+}
+function stripJsonComments(content) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    let stringChar = '';
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        if (inString) {
+            result += ch;
+            if (ch === '\\' && i + 1 < content.length) {
+                result += next;
+                i += 2;
+                continue;
+            }
+            if (ch === stringChar) {
+                inString = false;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === '\'') {
+            inString = true;
+            stringChar = ch;
+            result += ch;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < content.length && content[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < content.length - 1 && !(content[i] === '*' && content[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}

package/dist/compiler/durable-object-pipeline.d.ts

@@ -1,6 +1,10 @@
-import { type DoConfigEntry, type DoHandlerEntry, type OrmDatabaseEntry } from './compiler-shared.js';
-export declare function discoverDurableObjects(srcDir: string, configDoEntries: DoConfigEntry[], ormDatabases: OrmDatabaseEntry[]): {
-    config: DoConfigEntry[];
+import { type DoHandlerEntry } from './compiler-shared.js';
+export declare function discoverDurableObjects(srcDir: string): {
+    config: {
+        binding: string;
+        className: string;
+        files?: string[];
+    }[];
     handlers: DoHandlerEntry[];
 };
 export declare function generateHandlerProxy(handler: DoHandlerEntry, opts: {

package/dist/compiler/durable-object-pipeline.js

@@ -3,27 +3,14 @@ import * as path from 'node:path';
 import * as ts from 'typescript';
 import { toSafeIdentifier, } from './compiler-shared.js';
 import { discoverFilesWithExtensions, discoverFilesWithSuffix } from './convention-discovery.js';
-export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
+export function discoverDurableObjects(srcDir) {
     const serverDir = path.join(srcDir, 'server');
     const legacyDir = path.join(srcDir, 'durable-objects');
     const serverDoFiles = discoverFilesWithSuffix(serverDir, '.do.ts');
     const legacyDoFiles = discoverFilesWithSuffix(legacyDir, '.ts');
     const discoveredFiles = Array.from(new Set([...serverDoFiles, ...legacyDoFiles]));
     if (discoveredFiles.length === 0) {
-        return { config: configDoEntries, handlers: [] };
-    }
-    const bindings = new Set(configDoEntries.map((d) => d.binding));
-    const fileToBinding = new Map();
-    for (const entry of configDoEntries) {
-        for (const rawFile of entry.files ?? []) {
-            const normalized = rawFile.trim().replace(/^\.?[\\/]/, '').replace(/\\/g, '/').toLowerCase();
-            if (!normalized)
-                continue;
-            fileToBinding.set(normalized, entry.binding);
-            const base = path.basename(normalized);
-            if (!fileToBinding.has(base))
-                fileToBinding.set(base, entry.binding);
-        }
+        return { config: [], handlers: [] };
     }
     const handlers = [];
     const handlerIdToAbsPath = new Map();
@@ -48,28 +35,17 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
             continue;
         // Binding resolution:
         // 1) explicit static binding declared in the class
-        // 2) config-mapped file name
-        // 3) if exactly one binding exists, infer it
+        // 2) derive from the handler file name
         let binding = null;
         const bindingMatch = source.match(/static\s+binding\s*=\s*['"](\w+)['"]/);
         if (bindingMatch) {
             binding = bindingMatch[1];
         }
         else {
-            const normalizedFile = file.replace(/\\/g, '/').toLowerCase();
-            const normalizedRelFromSrc = path.relative(srcDir, absPath).replace(/\\/g, '/').toLowerCase();
-            binding = className ? (configDoEntries.find((entry) => entry.className === className)?.binding ?? null) : null;
-            if (!binding) {
-                binding = fileToBinding.get(normalizedRelFromSrc) ?? fileToBinding.get(normalizedFile) ?? null;
-            }
-            if (!binding && configDoEntries.length === 1) {
-                binding = configDoEntries[0].binding;
-            }
+            binding = deriveBindingFromFile(file);
         }
         if (!binding)
             continue;
-        if (!bindings.has(binding))
-            continue;
         const classMethods = className ? extractClassMethods(absPath, source, className) : [];
         const fileName = path
             .relative(absPath.startsWith(serverDir) ? serverDir : legacyDir, absPath)
@@ -103,17 +79,14 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
         }
     }
     // Build config entries from discovered handlers (de-duped by binding).
-    // Prefer class name from the original config entry (e.g. from wrangler.jsonc).
+    // The handler source is authoritative; wrangler.jsonc is then synced from this.
     const discoveredConfigByBinding = new Map();
     for (const handler of handlers) {
-        const configEntry = configDoEntries.find((e) => e.binding === handler.binding);
         const existing = discoveredConfigByBinding.get(handler.binding);
         if (!existing) {
             discoveredConfigByBinding.set(handler.binding, {
                 binding: handler.binding,
-                // Use config class name when available (authoritative, e.g. from wrangler.jsonc).
-                className: configEntry?.className ?? handler.className ?? handler.binding,
-                stubId: configEntry?.stubId,
+                className: handler.className ?? deriveClassNameFromFile(path.basename(handler.absPath)),
                 files: [path.basename(handler.absPath)],
             });
         }
@@ -121,9 +94,32 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
             existing.files?.push(path.basename(handler.absPath));
         }
     }
-    void ormDatabases;
     return { config: [...discoveredConfigByBinding.values()], handlers };
 }
+function deriveBindingFromFile(fileName) {
+    const normalized = fileName
+        .replace(/\.(ts|tsx|js|mjs|cjs)$/i, '')
+        .replace(/\.do$/i, '')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
+    if (!normalized)
+        return 'DURABLE_OBJECT';
+    return normalized.endsWith('_DO') ? normalized : `${normalized}_DO`;
+}
+function deriveClassNameFromFile(fileName) {
+    const normalized = fileName
+        .replace(/\.(ts|tsx|js|mjs|cjs)$/i, '')
+        .replace(/\.do$/i, '');
+    const base = normalized
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+    if (!base)
+        return 'DurableObjectHandler';
+    return base.endsWith('DO') ? base : `${base}DO`;
+}
 // ---------------------------------------------------------------------------
 // TypeScript AST helpers
 // ---------------------------------------------------------------------------

package/dist/compiler/index.js

@@ -7,7 +7,7 @@ import { compileAssets } from './asset-pipeline.js';
 import { compileApiRoute } from './api-route-pipeline.js';
 import { createClientModuleCompiler } from './client-module-pipeline.js';
 import { createComponentCompiler } from './component-pipeline.js';
-import { readAssetsPrefix, readAuthConfig, readDoConfig, readOrmConfig, readSecurityConfig, readUiConfigValues, readUiTheme, } from './config-reading.js';
+import { readAssetsPrefix, readAuthConfig, readOrmConfig, readSecurityConfig, readUiConfigValues, readUiTheme, } from './config-reading.js';
 import { discoverContainerFiles, discoverConventionClassFiles, discoverWorkflowFiles, } from './convention-discovery.js';
 import { discoverDurableObjects, generateHandlerProxy } from './durable-object-pipeline.js';
 import { compileErrorPages } from './error-page-pipeline.js';
@@ -132,12 +132,11 @@ export async function compile(options) {
     // Read security config from kuratchi.config.ts
     const securityConfig = readSecurityConfig(projectDir);
     // Auto-discover Durable Objects from .do.ts files (config optional, only needed for stubId)
-    const configDoEntries = readDoConfig(projectDir);
-    const { config: doConfig, handlers: doHandlers } = discoverDurableObjects(srcDir, configDoEntries, ormDatabases);
+    const { config: doConfig, handlers: doHandlers } = discoverDurableObjects(srcDir);
     // Auto-discover convention-based worker class files (no config needed)
     const containerConfig = discoverContainerFiles(projectDir);
     const workflowConfig = discoverWorkflowFiles(projectDir);
-    const agentConfig = discoverConventionClassFiles(projectDir, path.join('src', 'server'), '.agent.ts', '.agent');
+    const agentConfig = discoverConventionClassFiles(projectDir, path.join('src', 'server'), '.agents.ts', '.agents');
     // Generate handler proxy modules in .kuratchi/do/ (must happen BEFORE route processing
     // so that $durable-objects/X imports can be redirected to the generated proxies)
     const doProxyDir = path.join(projectDir, '.kuratchi', 'do');
@@ -302,12 +301,18 @@ export async function compile(options) {
     // routes.ts already exports the default fetch handler and all named DO classes;
     // worker.ts explicitly re-exports them so wrangler.jsonc can reference a
     // stable filename while routes.ts is freely regenerated.
+    // If user has src/index.ts with a default export, merge it with the generated worker
+    // to support scheduled, queue, and other Cloudflare Worker handlers.
+    const userIndexFile = path.join(srcDir, 'index.ts');
+    const hasUserIndex = fs.existsSync(userIndexFile) &&
+        fs.readFileSync(userIndexFile, 'utf-8').includes('export default');
     const workerFile = path.join(outDir, 'worker.ts');
     writeIfChanged(workerFile, buildWorkerEntrypointSource({
         projectDir,
         outDir,
         doClassNames: doConfig.map((entry) => entry.className),
         workerClassEntries: [...agentConfig, ...containerConfig, ...workflowConfig],
+        hasUserIndex,
     }));
     writeIfChanged(path.join(outDir, 'worker.js'), buildCompatEntrypointSource('./worker.ts'));
     // Auto-sync wrangler.jsonc with workflow/container/DO config from kuratchi.config.ts
@@ -324,12 +329,17 @@ export async function compile(options) {
         copyDirIfChanged(srcAssetsDir, publicAssetsDir);
         syncedAssetsDirectory = path.relative(projectDir, publicDir).replace(/\\/g, '/');
     }
+    // Convert agent config to DO config format (agents are Durable Objects)
+    const agentDoConfig = agentConfig.map((entry) => {
+        const binding = entry.className.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase();
+        return { binding, className: entry.className };
+    });
     syncWranglerConfigPipeline({
         projectDir,
         config: {
             workflows: workflowConfig,
             containers: containerConfig,
-            durableObjects: doConfig,
+            durableObjects: [...doConfig, ...agentDoConfig],
             assetsDirectory: syncedAssetsDirectory,
         },
         writeFile: writeIfChanged,

package/dist/compiler/parser.js

@@ -1135,6 +1135,7 @@ export function parseFile(source, options = {}) {
     const actionFunctions = [];
     const pollFunctions = [];
     const dataGetQueries = [];
+    let warnedLegacyActionAttrs = false;
     for (const tag of templateTags) {
         if (tag.closing)
             continue;
@@ -1143,6 +1144,11 @@ export function parseFile(source, options = {}) {
             actionFunctions.push(actionExpr);
         }
         for (const [attrName, attrValue] of tag.attrs.entries()) {
+            if (!warnedLegacyActionAttrs && (attrName === 'data-action' || attrName === 'data-args')) {
+                warnedLegacyActionAttrs = true;
+                console.warn(`[kuratchi] ${options.filePath || kind}: authored data-action/data-args are deprecated. ` +
+                    `Use data-post={fn(...)} or action={fn} instead.`);
+            }
             if (/^on[A-Za-z]+$/i.test(attrName)) {
                 const actionCall = extractCallExpression(attrValue);
                 if (actionCall && !actionFunctions.includes(actionCall.fnName))

package/dist/compiler/routes-module-feature-blocks.js

@@ -383,7 +383,11 @@ function buildDurableObjectBlock(opts) {
             doResolverLines.push(`  });`);
         }
         else {
-            doResolverLines.push(`  // No 'stubId' config for ${doEntry.binding} - stub must be obtained manually`);
+            doResolverLines.push(`  __registerDoResolver('${doEntry.binding}', async () => {`);
+            doResolverLines.push(`    const __ns = __env['${doEntry.binding}'];`);
+            doResolverLines.push(`    if (!__ns?.idFromName || !__ns?.get) return null;`);
+            doResolverLines.push(`    return __ns.get(__ns.idFromName('global'));`);
+            doResolverLines.push(`  });`);
         }
     }
     return {

package/dist/compiler/template.js

@@ -37,6 +37,36 @@ const JS_CONTROL_PATTERNS = [
 function isJsControlLine(line) {
     return JS_CONTROL_PATTERNS.some(p => p.test(line));
 }
+/** HTML boolean attributes that should be present or absent, never have a value */
+const BOOLEAN_ATTRIBUTES = new Set([
+    'disabled',
+    'checked',
+    'selected',
+    'readonly',
+    'required',
+    'hidden',
+    'open',
+    'autofocus',
+    'autoplay',
+    'controls',
+    'default',
+    'defer',
+    'formnovalidate',
+    'inert',
+    'ismap',
+    'itemscope',
+    'loop',
+    'multiple',
+    'muted',
+    'nomodule',
+    'novalidate',
+    'playsinline',
+    'reversed',
+    'async',
+]);
+function isBooleanAttribute(name) {
+    return BOOLEAN_ATTRIBUTES.has(name.toLowerCase());
+}
 const FRAGMENT_OPEN_MARKER = '<!--__KURATCHI_FRAGMENT_OPEN:';
 const FRAGMENT_CLOSE_MARKER = '<!--__KURATCHI_FRAGMENT_CLOSE-->';
 export function splitTemplateRenderSections(template) {
@@ -1130,9 +1160,13 @@ function compileHtmlSegment(line, actionNames, rpcNameMap, options = {}) {
                     pos = closeIdx + 1;
                     continue;
                 }
-                else if (attrName === 'disabled' || attrName === 'checked' || attrName === 'hidden' || attrName === 'readonly') {
-                    // Boolean attributes: disabled={expr} → conditionally include
-                    result += `"\${${inner} ? '' : undefined}"`;
+                else if (isBooleanAttribute(attrName)) {
+                    // Boolean attributes: disabled={expr} → conditionally include the attribute or omit entirely
+                    // Remove the trailing "attrName=" we already appended, we'll handle it with a ternary
+                    result = result.replace(new RegExp(`\\s*${attrName}=$`), '');
+                    result += `\${${inner} ? ' ${attrName}' : ''}`;
+                    pos = closeIdx + 1;
+                    continue;
                 }
                 else {
                     // Regular attribute: value={expr} → value="escaped"

package/dist/compiler/worker-output-pipeline.d.ts

@@ -10,5 +10,6 @@ export declare function buildWorkerEntrypointSource(opts: {
     outDir: string;
     doClassNames: string[];
     workerClassEntries: WorkerClassExportEntry[];
+    hasUserIndex?: boolean;
 }): string;
 export declare function buildCompatEntrypointSource(targetFile: string): string;

package/dist/compiler/worker-output-pipeline.js

@@ -29,13 +29,18 @@ export function buildWorkerEntrypointSource(opts) {
         }
         return `export { ${entry.className} } from '${importPath}';`;
     });
-    return [
+    const lines = [
         '// Auto-generated by kuratchi — do not edit.',
-        "export { default } from './routes.ts';",
-        ...opts.doClassNames.map((className) => `export { ${className} } from './routes.ts';`),
-        ...workerClassExports,
-        '',
-    ].join('\n');
+    ];
+    // If user has src/index.ts with a default export, merge it with the generated fetch handler
+    if (opts.hasUserIndex) {
+        lines.push("import __generatedWorker from './routes.ts';", "import __userWorker from '../src/index.ts';", '', '// Merge user worker exports (scheduled, queue, etc.) with generated fetch handler', 'export default {', '  ...__userWorker,', '  fetch: __generatedWorker.fetch,', '};');
+    }
+    else {
+        lines.push("export { default } from './routes.ts';");
+    }
+    lines.push(...opts.doClassNames.map((className) => `export { ${className} } from './routes.ts';`), ...workerClassExports, '');
+    return lines.join('\n');
 }
 export function buildCompatEntrypointSource(targetFile) {
     return [

package/dist/compiler/wrangler-sync.js

@@ -1,5 +1,26 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+function nextMigrationTag(existing) {
+    const used = new Set(existing
+        .map((entry) => (entry && typeof entry.tag === 'string' ? entry.tag : null))
+        .filter(Boolean));
+    let maxNumeric = 0;
+    for (const tag of used) {
+        const match = /^v(\d+)$/i.exec(String(tag));
+        if (match) {
+            maxNumeric = Math.max(maxNumeric, Number(match[1]));
+        }
+    }
+    let candidate = `v${maxNumeric > 0 ? maxNumeric + 1 : 1}`;
+    if (!used.has(candidate))
+        return candidate;
+    let index = maxNumeric + 1;
+    while (used.has(candidate)) {
+        index += 1;
+        candidate = `v${index}`;
+    }
+    return candidate;
+}
 function stripJsonComments(content) {
     let result = '';
     let i = 0;
@@ -169,8 +190,34 @@ export function syncWranglerConfig(opts) {
                 changed = true;
                 console.log(`[kuratchi] Added durable_object "${durableObject.binding}" to wrangler config`);
             }
+            else if (existing.class_name !== durableObject.className) {
+                existing.class_name = durableObject.className;
+                changed = true;
+                console.log(`[kuratchi] Updated durable_object "${durableObject.binding}" class_name to "${durableObject.className}"`);
+            }
         }
         wranglerConfig.durable_objects.bindings = existingBindings;
+        const existingMigrations = Array.isArray(wranglerConfig.migrations) ? wranglerConfig.migrations : [];
+        const knownClasses = new Set();
+        for (const migration of existingMigrations) {
+            const newClasses = Array.isArray(migration?.new_sqlite_classes) ? migration.new_sqlite_classes : [];
+            for (const className of newClasses) {
+                if (typeof className === 'string' && className)
+                    knownClasses.add(className);
+            }
+        }
+        const missingClasses = opts.config.durableObjects
+            .map((entry) => entry.className)
+            .filter((className) => !knownClasses.has(className));
+        if (missingClasses.length > 0) {
+            existingMigrations.push({
+                tag: nextMigrationTag(existingMigrations),
+                new_sqlite_classes: missingClasses,
+            });
+            wranglerConfig.migrations = existingMigrations;
+            changed = true;
+            console.log(`[kuratchi] Added durable object migration for ${missingClasses.join(', ')}`);
+        }
     }
     if (opts.config.assetsDirectory !== undefined) {
         const existing = wranglerConfig.assets;