@kuratchi/js 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * KuratchiJS — Public API
+ *
+ * A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax.
+ */
+export { createApp } from './runtime/app.js';
+export { defineConfig } from './runtime/config.js';
+export { getEnv, getCtx, getRequest, getLocals, getParams, getParam, redirect, goto, setBreadcrumbs, getBreadcrumbs, breadcrumbsHome, breadcrumbsPrev, breadcrumbsNext, breadcrumbsCurrent, buildDefaultBreadcrumbs, } from './runtime/context.js';
+export { kuratchiDO, doRpc } from './runtime/do.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 } from './runtime/types.js';
+export type { RpcOf } from './runtime/do.js';
+export { compile } from './compiler/index.js';

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * KuratchiJS — Public API
+ *
+ * A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax.
+ */
+// Runtime
+export { createApp } from './runtime/app.js';
+export { defineConfig } from './runtime/config.js';
+export { getEnv, getCtx, getRequest, getLocals, getParams, getParam, redirect, goto, setBreadcrumbs, getBreadcrumbs, breadcrumbsHome, breadcrumbsPrev, breadcrumbsNext, breadcrumbsCurrent, buildDefaultBreadcrumbs, } from './runtime/context.js';
+export { kuratchiDO, doRpc } from './runtime/do.js';
+export { extractSubdomainSlug, extractSlugFromPrefix, matchContainerViewPath, rewriteProxyLocationHeader, buildContainerRequest, createContainerEnvVars, startContainer, proxyToContainer, handleContainerRouting, forwardJsonPostToContainerDO, 
+// Compatibility aliases
+matchSiteViewPath, buildSiteContainerRequest, createWpContainerEnvVars, startSiteContainer, proxyToSiteContainer, } from './runtime/containers.js';
+// Compiler (for build tooling)
+export { compile } from './compiler/index.js';

package/dist/runtime/app.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Core application — the Worker fetch() handler.
+ *
+ * Takes an AppConfig, returns a standard Cloudflare Worker fetch handler.
+ */
+import type { AppConfig, Env } from './types.js';
+/**
+ * Create a Cloudflare Worker fetch handler from an AppConfig.
+ */
+export declare function createApp<E extends Env = Env>(config: AppConfig<E>): {
+    fetch(request: Request, env: E, ctx: ExecutionContext): Promise<Response>;
+};

package/dist/runtime/app.js

@@ -0,0 +1,118 @@
+/**
+ * Core application — the Worker fetch() handler.
+ *
+ * Takes an AppConfig, returns a standard Cloudflare Worker fetch handler.
+ */
+import { Router } from './router.js';
+/**
+ * Create a Cloudflare Worker fetch handler from an AppConfig.
+ */
+export function createApp(config) {
+    const router = new Router();
+    const routes = config.routes ?? [];
+    const layouts = config.layouts ?? {};
+    // Register routes
+    for (let i = 0; i < routes.length; i++) {
+        router.add(routes[i].pattern, i);
+    }
+    // The Worker fetch handler
+    return {
+        async fetch(request, env, ctx) {
+            const url = new URL(request.url);
+            // Build base context (params filled in after routing)
+            const context = {
+                request,
+                env,
+                ctx,
+                params: {},
+                locals: {},
+                url,
+            };
+            // --- Static files from public/ ---
+            // Handled by wrangler's [site] config, not here.
+            // --- Route matching ---
+            const match = router.match(url.pathname);
+            // Build the final handler (route dispatch)
+            const routeHandler = async () => {
+                if (!match) {
+                    return new Response('Not Found', { status: 404, headers: { 'content-type': 'text/html' } });
+                }
+                const route = routes[match.index];
+                context.params = match.params;
+                // --- RPC calls: POST ?/_rpc/functionName ---
+                if (request.method === 'POST' && url.searchParams.has('_rpc')) {
+                    const fnName = url.searchParams.get('_rpc');
+                    const rpcFn = route.rpc?.[fnName];
+                    if (!rpcFn) {
+                        return new Response(JSON.stringify({ error: `RPC function '${fnName}' not found` }), {
+                            status: 404,
+                            headers: { 'content-type': 'application/json' },
+                        });
+                    }
+                    try {
+                        const body = await request.json();
+                        const result = await rpcFn(body.args ?? [], env, context);
+                        return new Response(JSON.stringify(result), {
+                            headers: { 'content-type': 'application/json' },
+                        });
+                    }
+                    catch (err) {
+                        return new Response(JSON.stringify({ error: err.message }), {
+                            status: 500,
+                            headers: { 'content-type': 'application/json' },
+                        });
+                    }
+                }
+                // --- Form actions: POST ?/actionName ---
+                if (request.method === 'POST') {
+                    const actionParam = [...url.searchParams.keys()].find(k => k.startsWith('/'));
+                    if (actionParam) {
+                        const actionName = actionParam.slice(1); // remove leading /
+                        const actionFn = route.actions?.[actionName];
+                        if (!actionFn) {
+                            return new Response(`Action '${actionName}' not found`, { status: 404 });
+                        }
+                        try {
+                            const formData = await request.formData();
+                            const actionResult = await actionFn(formData, env, context);
+                            // After action, re-run load and re-render with action result
+                            const loadData = route.load ? await route.load(context) : {};
+                            const data = { ...loadData, actionResult, actionName };
+                            return renderPage(route, data, layouts);
+                        }
+                        catch (err) {
+                            // Re-render with error
+                            const loadData = route.load ? await route.load(context) : {};
+                            const data = { ...loadData, actionError: err.message, actionName };
+                            return renderPage(route, data, layouts);
+                        }
+                    }
+                }
+                // --- GET: load + render ---
+                try {
+                    const data = route.load ? await route.load(context) : {};
+                    return renderPage(route, data, layouts);
+                }
+                catch (err) {
+                    return new Response(`Server Error: ${err.message}`, {
+                        status: 500,
+                        headers: { 'content-type': 'text/html' },
+                    });
+                }
+            };
+            return routeHandler();
+        },
+    };
+}
+/** Render a page through its layout */
+function renderPage(route, data, layouts) {
+    const content = route.render(data);
+    const layoutName = route.layout ?? 'default';
+    const layout = layouts[layoutName];
+    const html = layout
+        ? layout.render({ content, data })
+        : content;
+    return new Response(html, {
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    });
+}

package/dist/runtime/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration helper — typed identity function for kuratchi.config.ts
+ */
+import type { kuratchiConfig, Env } from './types.js';
+export declare function defineConfig<E extends Env = Env>(config: kuratchiConfig<E>): kuratchiConfig<E>;

package/dist/runtime/config.js

@@ -0,0 +1,6 @@
+/**
+ * Configuration helper — typed identity function for kuratchi.config.ts
+ */
+export function defineConfig(config) {
+    return config;
+}

package/dist/runtime/containers.d.ts

@@ -0,0 +1,61 @@
+type ContainerLike = {
+    start?: (options: {
+        envVars?: Record<string, string>;
+    }) => Promise<unknown>;
+    fetch: (request: Request) => Promise<Response>;
+};
+type ContainerFactory = (namespace: DurableObjectNamespace, slug: string) => ContainerLike;
+export interface StartContainerOptions {
+    namespace: DurableObjectNamespace;
+    slug: string;
+    containerFactory: ContainerFactory;
+    envVars?: Record<string, string>;
+}
+export interface ProxyToContainerOptions extends StartContainerOptions {
+    request: Request;
+    onError?: (slug: string, err: unknown) => Response;
+}
+export interface ContainerPathMatch {
+    slug: string;
+    containerPath: string;
+}
+export interface HandleContainerRoutingOptions {
+    request: Request;
+    appDomain: string;
+    proxyToSlug: (slug: string, request: Request) => Promise<Response>;
+    sitePrefix?: string;
+    viewSegment?: string;
+    blockContainerPathPrefix?: string;
+    skipSubdomainWhenPathStartsWith?: string;
+}
+export declare function extractSubdomainSlug(host: string, appDomain: string): string | null;
+export declare function extractSlugFromPrefix(pathname: string, prefix: string): string | null;
+export declare function matchContainerViewPath(pathname: string, opts?: {
+    sitePrefix?: string;
+    viewSegment?: string;
+}): ContainerPathMatch | null;
+export declare function rewriteProxyLocationHeader(location: string, slug: string, opts?: {
+    sitePrefix?: string;
+    viewSegment?: string;
+}): string;
+export declare function buildContainerRequest(request: Request, containerPath: string): Request;
+export declare function createContainerEnvVars(opts: {
+    slug: string;
+    vars: Record<string, string | ((slug: string) => string)>;
+}): Record<string, string>;
+export declare function startContainer(options: StartContainerOptions): Promise<ContainerLike>;
+export declare function proxyToContainer(options: ProxyToContainerOptions): Promise<Response>;
+export declare function forwardJsonPostToContainerDO(options: {
+    namespace: DurableObjectNamespace;
+    slug: string;
+    containerFactory: ContainerFactory;
+    request: Request;
+    targetPath?: string;
+}): Promise<Response>;
+export declare function handleContainerRouting(options: HandleContainerRoutingOptions): Promise<Response | null>;
+export declare const startSiteContainer: typeof startContainer;
+export declare const proxyToSiteContainer: typeof proxyToContainer;
+export declare const matchSiteViewPath: typeof matchContainerViewPath;
+export declare const buildSiteContainerRequest: typeof buildContainerRequest;
+export declare const createWpContainerEnvVars: typeof createContainerEnvVars;
+export {};

package/dist/runtime/containers.js

@@ -0,0 +1,127 @@
+export function extractSubdomainSlug(host, appDomain) {
+    if (host.endsWith('.localhost')) {
+        const slug = host.slice(0, -'.localhost'.length);
+        return slug || null;
+    }
+    if (host.endsWith('.' + appDomain)) {
+        const slug = host.slice(0, -(appDomain.length + 1));
+        return slug && !slug.includes('.') ? slug : null;
+    }
+    return null;
+}
+export function extractSlugFromPrefix(pathname, prefix) {
+    if (!pathname.startsWith(prefix))
+        return null;
+    const rest = pathname.slice(prefix.length);
+    const slug = rest.split('/')[0];
+    return slug || null;
+}
+export function matchContainerViewPath(pathname, opts) {
+    const sitePrefix = opts?.sitePrefix ?? '/sites/';
+    const viewSegment = opts?.viewSegment ?? '/view';
+    if (!pathname.startsWith(sitePrefix))
+        return null;
+    const rest = pathname.slice(sitePrefix.length);
+    const slashIdx = rest.indexOf('/');
+    if (slashIdx <= 0)
+        return null;
+    const slug = rest.slice(0, slashIdx);
+    const after = rest.slice(slashIdx);
+    if (!(after === viewSegment || after.startsWith(viewSegment + '/')))
+        return null;
+    const containerPath = after.slice(viewSegment.length) || '/';
+    return { slug, containerPath };
+}
+export function rewriteProxyLocationHeader(location, slug, opts) {
+    const sitePrefix = opts?.sitePrefix ?? '/sites';
+    const viewSegment = opts?.viewSegment ?? '/view';
+    const prefix = `${sitePrefix}/${slug}${viewSegment}`;
+    if (location.startsWith('/'))
+        return prefix + location;
+    if (location.startsWith('http://') || location.startsWith('https://')) {
+        const loc = new URL(location);
+        loc.pathname = prefix + loc.pathname;
+        return loc.toString();
+    }
+    return location;
+}
+export function buildContainerRequest(request, containerPath) {
+    const url = new URL(request.url);
+    const target = new URL(containerPath, url.origin);
+    target.search = url.search;
+    return new Request(target.toString(), request);
+}
+export function createContainerEnvVars(opts) {
+    const out = {};
+    for (const [key, value] of Object.entries(opts.vars)) {
+        out[key] = typeof value === 'function' ? value(opts.slug) : value;
+    }
+    return out;
+}
+export async function startContainer(options) {
+    const container = options.containerFactory(options.namespace, options.slug);
+    if (options.envVars && container.start) {
+        await container.start({ envVars: options.envVars });
+    }
+    return container;
+}
+export async function proxyToContainer(options) {
+    try {
+        const container = await startContainer(options);
+        return await container.fetch(options.request);
+    }
+    catch (err) {
+        if (options.onError)
+            return options.onError(options.slug, err);
+        throw err;
+    }
+}
+export async function forwardJsonPostToContainerDO(options) {
+    const container = options.containerFactory(options.namespace, options.slug);
+    const body = await options.request.text();
+    const targetPath = options.targetPath ?? '/sql';
+    const doRequest = new Request(`https://do-internal${targetPath}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body,
+    });
+    return container.fetch(doRequest);
+}
+export async function handleContainerRouting(options) {
+    const sitePrefix = options.sitePrefix ?? '/sites/';
+    const viewSegment = options.viewSegment ?? '/view';
+    const blockedPrefix = options.blockContainerPathPrefix ?? '/__kuratchi/';
+    const skipSubdomainPrefix = options.skipSubdomainWhenPathStartsWith ?? '/sites/';
+    const url = new URL(options.request.url);
+    const hostHeader = options.request.headers.get('host') || url.host;
+    const host = hostHeader.split(':')[0];
+    const subdomainSlug = extractSubdomainSlug(host, options.appDomain);
+    if (subdomainSlug && !url.pathname.startsWith(skipSubdomainPrefix)) {
+        return options.proxyToSlug(subdomainSlug, options.request);
+    }
+    const pathMatch = matchContainerViewPath(url.pathname, { sitePrefix, viewSegment });
+    if (!pathMatch)
+        return null;
+    if (pathMatch.containerPath.startsWith(blockedPrefix)) {
+        return new Response('Not Found', { status: 404 });
+    }
+    const containerRequest = buildContainerRequest(options.request, pathMatch.containerPath);
+    const res = await options.proxyToSlug(pathMatch.slug, containerRequest);
+    const location = res.headers.get('location');
+    if (location && res.status >= 300 && res.status < 400) {
+        const rewritten = rewriteProxyLocationHeader(location, pathMatch.slug, {
+            sitePrefix: sitePrefix.endsWith('/') ? sitePrefix.slice(0, -1) : sitePrefix,
+            viewSegment,
+        });
+        const newRes = new Response(res.body, res);
+        newRes.headers.set('location', rewritten);
+        return newRes;
+    }
+    return res;
+}
+// Backwards-compatible aliases (to avoid breaking early adopters)
+export const startSiteContainer = startContainer;
+export const proxyToSiteContainer = proxyToContainer;
+export const matchSiteViewPath = matchContainerViewPath;
+export const buildSiteContainerRequest = buildContainerRequest;
+export const createWpContainerEnvVars = createContainerEnvVars;

package/dist/runtime/context.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Request-scoped context.
+ *
+ * Env bindings: use `import { env } from 'cloudflare:workers'` directly.
+ * Request/ctx/locals: set per-request by the framework, accessed via helpers.
+ *
+ * Workers are single-threaded per request — module-scoped
+ * variables are safe and require no Node.js compat flags.
+ */
+export interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    current?: boolean;
+}
+/** Called by the framework at the start of each request */
+export declare function __setRequestContext(ctx: any, request: Request): void;
+/**
+ * @deprecated Use `import { env } from 'cloudflare:workers'` instead.
+ * Kept for backward compatibility — delegates to the native env import.
+ */
+export declare function getEnv<T = any>(): T;
+/** @internal — called by compiler to stash env ref for getEnv() compat */
+export declare function __setEnvCompat(env: any): void;
+/** Get the execution context (waitUntil, passThroughOnException) */
+export declare function getCtx(): ExecutionContext;
+/** Get the current request */
+export declare function getRequest(): Request;
+/** Get request-scoped locals (session, auth, custom data) */
+export declare function getLocals<T = Record<string, any>>(): T;
+/** Get matched route params for the current request (e.g. { slug: 'my-post' }) */
+export declare function getParams<T = Record<string, string>>(): T;
+/** Get one matched route param by key (e.g. getParam('slug')) */
+export declare function getParam(name: string): string | undefined;
+/**
+ * Server-side redirect helper for actions/load logic.
+ * Sets the post-action redirect target consumed by the framework's PRG flow.
+ */
+export declare function redirect(path: string, status?: number): void;
+/** Backward-compatible alias for redirect() */
+export declare function goto(path: string, status?: number): void;
+export declare function setBreadcrumbs(items: BreadcrumbItem[]): void;
+export declare function getBreadcrumbs(): BreadcrumbItem[];
+export declare function breadcrumbsHome(label?: string, href?: string): BreadcrumbItem;
+export declare function breadcrumbsPrev(label: string, href: string): BreadcrumbItem;
+export declare function breadcrumbsNext(label: string, href: string): BreadcrumbItem;
+export declare function breadcrumbsCurrent(label: string): BreadcrumbItem;
+/** Build a reasonable default breadcrumb trail from pathname + params */
+export declare function buildDefaultBreadcrumbs(pathname: string, _params?: Record<string, string>): BreadcrumbItem[];
+/** Set a value on request-scoped locals (used by framework internals) */
+export declare function __setLocal(key: string, value: any): void;
+/** Get the full locals object reference (used by framework internals) */
+export declare function __getLocals(): Record<string, any>;
+/** HTML-escape a value for safe output in templates */
+export declare function __esc(v: any): string;

package/dist/runtime/context.js

@@ -0,0 +1,134 @@
+/**
+ * Request-scoped context.
+ *
+ * Env bindings: use `import { env } from 'cloudflare:workers'` directly.
+ * Request/ctx/locals: set per-request by the framework, accessed via helpers.
+ *
+ * Workers are single-threaded per request — module-scoped
+ * variables are safe and require no Node.js compat flags.
+ */
+let __ctx = null;
+let __request = null;
+let __locals = {};
+/** Called by the framework at the start of each request */
+export function __setRequestContext(ctx, request) {
+    __ctx = ctx;
+    __request = request;
+    __locals = {};
+    // Expose context on globalThis for @kuratchi/auth and other packages
+    // Workers are single-threaded per request — this is safe
+    globalThis.__kuratchi_context__ = {
+        get request() { return __request; },
+        get locals() { return __locals; },
+    };
+}
+/**
+ * @deprecated Use `import { env } from 'cloudflare:workers'` instead.
+ * Kept for backward compatibility — delegates to the native env import.
+ */
+export function getEnv() {
+    return globalThis.__cloudflare_env__;
+}
+/** @internal — called by compiler to stash env ref for getEnv() compat */
+export function __setEnvCompat(env) {
+    globalThis.__cloudflare_env__ = env;
+}
+/** Get the execution context (waitUntil, passThroughOnException) */
+export function getCtx() {
+    if (!__ctx)
+        throw new Error('getCtx() called outside of a request context');
+    return __ctx;
+}
+/** Get the current request */
+export function getRequest() {
+    if (!__request)
+        throw new Error('getRequest() called outside of a request context');
+    return __request;
+}
+/** Get request-scoped locals (session, auth, custom data) */
+export function getLocals() {
+    return __locals;
+}
+/** Get matched route params for the current request (e.g. { slug: 'my-post' }) */
+export function getParams() {
+    return (__locals?.params ?? {});
+}
+/** Get one matched route param by key (e.g. getParam('slug')) */
+export function getParam(name) {
+    return (__locals?.params ?? {})[name];
+}
+/**
+ * Server-side redirect helper for actions/load logic.
+ * Sets the post-action redirect target consumed by the framework's PRG flow.
+ */
+export function redirect(path, status = 303) {
+    __locals.__redirectTo = path;
+    __locals.__redirectStatus = status;
+}
+/** Backward-compatible alias for redirect() */
+export function goto(path, status = 303) {
+    redirect(path, status);
+}
+export function setBreadcrumbs(items) {
+    __locals.__breadcrumbs = items;
+}
+export function getBreadcrumbs() {
+    return (__locals.__breadcrumbs ?? []);
+}
+export function breadcrumbsHome(label = 'Home', href = '/') {
+    return { label, href };
+}
+export function breadcrumbsPrev(label, href) {
+    return { label, href };
+}
+export function breadcrumbsNext(label, href) {
+    return { label, href };
+}
+export function breadcrumbsCurrent(label) {
+    return { label, current: true };
+}
+function titleizeSegment(segment) {
+    const decoded = decodeURIComponent(segment);
+    if (!decoded)
+        return '';
+    return decoded
+        .replace(/[-_]+/g, ' ')
+        .replace(/\b\w/g, (m) => m.toUpperCase());
+}
+/** Build a reasonable default breadcrumb trail from pathname + params */
+export function buildDefaultBreadcrumbs(pathname, _params = {}) {
+    const parts = pathname.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return [{ label: 'Home', current: true }];
+    const items = [{ label: 'Home', href: '/' }];
+    let acc = '';
+    for (let i = 0; i < parts.length; i++) {
+        acc += `/${parts[i]}`;
+        const isLast = i === parts.length - 1;
+        items.push({
+            label: titleizeSegment(parts[i]),
+            href: isLast ? undefined : acc,
+            current: isLast,
+        });
+    }
+    return items;
+}
+/** Set a value on request-scoped locals (used by framework internals) */
+export function __setLocal(key, value) {
+    __locals[key] = value;
+}
+/** Get the full locals object reference (used by framework internals) */
+export function __getLocals() {
+    return __locals;
+}
+/** HTML-escape a value for safe output in templates */
+export function __esc(v) {
+    if (v == null)
+        return '';
+    return String(v)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}

package/dist/runtime/do.d.ts

@@ -0,0 +1,81 @@
+/**
+ * KuratchiJS — Durable Object helpers
+ *
+ * kuratchiDO
+ *   Base class for DO handler modules. Extend it, write your methods,
+ *   declare `static binding = 'BINDING_NAME'` — the compiler does the rest.
+ *
+ *   - Methods are copied onto the generated DO class prototype
+ *   - RPC proxy exports are auto-generated for pages
+ *   - Stub resolvers are registered from config
+ *
+ * The compiler uses __registerDoResolver / __getDoStub internally.
+ * User code never touches these — they're wired up from kuratchi.config.ts.
+ */
+/** @internal — called by compiler-generated init code */
+export declare function __registerDoResolver(binding: string, resolver: () => Promise<any>): void;
+/** @internal — called by compiler-generated init code */
+export declare function __registerDoClassBinding(klass: Function, binding: string): void;
+/** @internal — called by compiler-generated RPC proxy modules */
+export declare function __getDoStub(binding: string): Promise<any>;
+/**
+ * Base class for Durable Object handler modules.
+ *
+ * ```ts
+ * // sites.ts — extend, write methods, done.
+ * export default class Sites extends kuratchiDO {
+ *   static binding = 'ORG_DB';
+ *
+ *   async getSites(userId: number) {
+ *     return (await this.db.sites.where({ userId }).many()).data ?? [];
+ *   }
+ * }
+ * ```
+ *
+ * `this.db` is the ORM instance — set by the generated DO class at runtime.
+ *
+ * Call `Sites.rpc()` in the same file if you need to call DO methods
+ * from worker-side helper functions:
+ *
+ * ```ts
+ * const remote = Sites.rpc();
+ *
+ * export async function createSite(formData: FormData) {
+ *   await remote.createSiteRecord({ name, slug, userId });
+ * }
+ * ```
+ */
+export declare class kuratchiDO {
+    db: Record<string, any>;
+    /** The DO namespace binding this handler belongs to (e.g. 'ORG_DB'). */
+    static binding: string;
+    /**
+     * Implicit RPC proxy getter.
+     *
+     * Lets handler modules call `MyDO.remote.someMethod()` without declaring
+     * `const remote = MyDO.rpc();` boilerplate.
+     */
+    static get remote(): any;
+    /**
+     * Create a typed RPC proxy for calling DO methods from worker-side code.
+     * The actual stub resolution is lazy — happens at call time, not import time.
+     */
+    static rpc<T extends typeof kuratchiDO>(this: T): RpcOf<InstanceType<T>>;
+}
+/**
+ * DX helper for worker-side code in DO handler modules.
+ *
+ * Usage:
+ * `const doSites = doRpc(Sites);`
+ * `await doSites.getSiteBySlug(slug);`
+ */
+export declare function doRpc<T extends typeof kuratchiDO>(klass: T): RpcOf<InstanceType<T>>;
+/** Extract only the method keys from a class instance (excludes 'db'). */
+type MethodKeys<T> = {
+    [K in keyof T]: K extends 'db' ? never : T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+/** Map class methods → RPC callers (same args, Promise-wrapped return). */
+export type RpcOf<T> = {
+    [K in MethodKeys<T>]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+};
+export {};