@kuratchi/js 0.0.21 → 0.0.22

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,8 +132,7 @@ 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);

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/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;

package/dist/create.js

@@ -192,11 +192,11 @@ function scaffold(dir, opts) {
     if (orm || enableDO) {
         dirs.push('src/schemas');
     }
-    if (orm) {
-        dirs.push('src/database');
+    if (orm || enableDO || auth) {
+        dirs.push('src/server');
     }
     if (enableDO) {
-        dirs.push('src/server', 'src/routes/notes');
+        dirs.push('src/routes/notes');
     }
     if (auth) {
         dirs.push('src/routes/auth', 'src/routes/auth/login', 'src/routes/auth/signup', 'src/routes/admin');
@@ -214,19 +214,19 @@ function scaffold(dir, opts) {
     write(dir, 'src/routes/index.html', genLandingPage(opts));
     if (orm) {
         write(dir, 'src/schemas/app.ts', genSchema(opts));
-        write(dir, 'src/database/items.ts', genItemsCrud());
+        write(dir, 'src/server/items.ts', genItemsCrud());
         write(dir, 'src/routes/items/index.html', genItemsPage());
     }
     if (enableDO) {
         write(dir, 'src/schemas/notes.ts', genNotesSchema());
         write(dir, 'src/server/notes.do.ts', genNotesDoHandler());
-        write(dir, 'src/database/notes.ts', genNotesDb());
+        write(dir, 'src/server/notes.ts', genNotesDb());
         write(dir, 'src/routes/notes/index.html', genNotesPage());
     }
     if (auth) {
         write(dir, '.dev.vars', genDevVars());
-        write(dir, 'src/database/auth.ts', genAuthFunctions());
-        write(dir, 'src/database/admin.ts', genAdminLoader());
+        write(dir, 'src/server/auth.ts', genAuthFunctions());
+        write(dir, 'src/server/admin.ts', genAdminLoader());
         write(dir, 'src/routes/auth/login/index.html', genLoginPage());
         write(dir, 'src/routes/auth/signup/index.html', genSignupPage());
         write(dir, 'src/routes/admin/index.html', genAdminPage());
@@ -449,7 +449,7 @@ export async function deleteNote(id: number): Promise<void> {
 }
 function genNotesPage() {
     return `<script>
-  import { getNotes, addNote, deleteNote } from '$database/notes';
+  import { getNotes, addNote, deleteNote } from '$server/notes';
 
   const notes = await getNotes();
 </script>
@@ -473,7 +473,7 @@ if (notes.length === 0) {
     for (const note of notes) {
       <article>
         <span>{note.title}</span>
-        <button data-action="deleteNote" data-args={JSON.stringify([note.id])}>Remove</button>
+        <button data-post={deleteNote(note.id)} data-refresh="" type="button">Remove</button>
       </article>
     }
   </section>
@@ -631,10 +631,10 @@ ${types}
 `;
 }
 function genItemsCrud() {
-    return `import { env } from 'cloudflare:workers';
-import { kuratchiORM } from '@kuratchi/orm';
-import { redirect } from '${FRAMEWORK_PACKAGE_NAME}';
-import type { Item } from './schemas/app';
+    return `import { env } from 'cloudflare:workers';
+import { kuratchiORM } from '@kuratchi/orm';
+import { redirect } from '${FRAMEWORK_PACKAGE_NAME}';
+import type { Item } from '../schemas/app';
 
 const db = kuratchiORM(() => (env as any).DB);
 
@@ -664,7 +664,7 @@ export async function toggleItem(id: number): Promise<void> {
 }
 function genItemsPage() {
     return `<script>
-  import { getItems, addItem, deleteItem, toggleItem } from '$database/items';
+  import { getItems, addItem, deleteItem, toggleItem } from '$server/items';
   import EmptyState from '@kuratchi/ui/empty-state.html';
 
   const items = await getItems();
@@ -690,10 +690,10 @@ if (items.length === 0) {
       <article>
         <span style={item.done ? 'text-decoration: line-through; opacity: 0.5' : ''}>{item.title}</span>
         <div>
-          <button data-action="toggleItem" data-args={JSON.stringify([item.id])}>
+          <button data-post={toggleItem(item.id)} data-refresh="" type="button">
             {item.done ? '↩' : '✓'}
           </button>
-          <button data-action="deleteItem" data-args={JSON.stringify([item.id])}>✕</button>
+          <button data-post={deleteItem(item.id)} data-refresh="" type="button">✕</button>
         </div>
       </article>
     }
@@ -905,7 +905,7 @@ export async function getAdminData() {
 }
 function genLoginPage() {
     return `<script>
-  import { signIn } from '$database/auth';
+  import { signIn } from '$server/auth';
   import AuthCard from '@kuratchi/ui/auth-card.html';
 </script>
 
@@ -933,7 +933,7 @@ function genLoginPage() {
 }
 function genSignupPage() {
     return `<script>
-  import { signUp } from '$database/auth';
+  import { signUp } from '$server/auth';
   import AuthCard from '@kuratchi/ui/auth-card.html';
 </script>
 
@@ -965,7 +965,7 @@ function genSignupPage() {
 }
 function genAdminPage() {
     return `<script>
-  import { getAdminData, signOut } from '$database/admin';
+  import { getAdminData, signOut } from '$server/admin';
   import Badge from '@kuratchi/ui/badge.html';
   import Card from '@kuratchi/ui/card.html';
   import DataList from '@kuratchi/ui/data-list.html';

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { SchemaValidationError, schema, } from './runtime/schema.js';
 export { ActionError } from './runtime/action.js';
 export { PageError } from './runtime/page-error.js';
 export { extractSubdomainSlug, extractSlugFromPrefix, matchContainerViewPath, rewriteProxyLocationHeader, buildContainerRequest, createContainerEnvVars, startContainer, proxyToContainer, handleContainerRouting, forwardJsonPostToContainerDO, matchSiteViewPath, buildSiteContainerRequest, createWpContainerEnvVars, startSiteContainer, proxyToSiteContainer, } from './runtime/containers.js';
-export type { AppConfig, kuratchiConfig, DatabaseConfig, AuthConfig, RouteContext, RouteModule, RuntimeContext, RuntimeDefinition, RuntimeStep, RuntimeNext, RuntimeErrorResult, } from './runtime/types.js';
+export type { AppConfig, kuratchiConfig, DatabaseConfig, DesktopConfig, DesktopRemoteBindingConfig, DesktopWindowConfig, AuthConfig, RouteContext, RouteModule, RuntimeContext, RuntimeDefinition, RuntimeStep, RuntimeNext, RuntimeErrorResult, } from './runtime/types.js';
 export type { RpcOf } from './runtime/do.js';
 export type { SchemaType, InferSchema } from './runtime/schema.js';
 export { url, pathname, searchParams, headers, method, params, slug } from './runtime/request.js';

package/dist/runtime/desktop.d.ts

@@ -0,0 +1,19 @@
+export interface DesktopNotificationPayload {
+    title: string;
+    body?: string;
+}
+export interface DesktopCommandRequest {
+    command: string;
+    workingDirectory?: string;
+    timeoutMs?: number;
+}
+export interface DesktopCommandResult {
+    ok: boolean;
+    error?: string | null;
+    exitCode: number;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function showDesktopNotification(payload: DesktopNotificationPayload): Promise<boolean>;
+export declare function runDesktopCommand(request: DesktopCommandRequest): Promise<DesktopCommandResult | null>;