@tokamakdev/tok 0.1.1-beta.106 → 0.1.1-beta.112

package/dist/worker-graph.mjs

@@ -0,0 +1,332 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
+import { WorkerTypes } from "./worker-types.mjs";
+const NATIVE_CONNECTION = "virtual:tokamak/native-connection";
+const NATIVE_CALLS = normalizePath(fileURLToPath(new URL("./native.mjs", import.meta.url)));
+/** Configure the two bundles through Cloudflare's public auxiliary-worker API. */
+export function createWorkerGraph(root, entry, output) {
+    const generated = path.join(output, "worker.mjs");
+    const types = path.join(root, "tokamak-env.d.ts");
+    const contracts = new WorkerTypes(root, entry);
+    contracts.discover();
+    const events = normalizePath(fileURLToPath(new URL("./entrypoint.js", import.meta.resolve("@tokamakdev/plugin/events"))));
+    let mainName;
+    let nativeName;
+    let appName;
+    let mainEnvironment;
+    let dev = false;
+    let mainServices;
+    /** The named entrypoints the main Worker's bindings were configured with. */
+    let configuredEntrypoints;
+    const entrypoints = () => Object.keys(contracts.named).join();
+    const signatures = new Map();
+    const development = normalizePath(fileURLToPath(new URL("./rpc/binding.mjs", import.meta.resolve("@tokamakdev/plugin/events"))));
+    let relay;
+    const serviceModule = (role) => `virtual:tokamak/service/${role}`;
+    const bindingsModule = (role) => `\0tokamak:bindings:${role}`;
+    const nativeContracts = () => Object.fromEntries(contracts.services().map(service => [service.entrypoint, service.contract]));
+    const sources = () => [...contracts.native.files, ...Object.values(contracts.main).flatMap(value => value.files),
+        ...contracts.plugins.flatMap(plugin => plugin.files)];
+    const services = (name) => contracts.services().map(({ binding, entrypoint }) => entrypoint === "default" ? { binding, service: workerName(name) } : { binding, service: workerName(name), entrypoint });
+    function bindings(role) {
+        const services = role === "main" ? mainServices : [{ binding: "MAIN", service: mainName }];
+        const result = {};
+        for (const service of services ?? []) {
+            const targets = service.service === mainName ? contracts.main
+                : service.service === nativeName ? nativeContracts() : undefined;
+            if (!targets)
+                continue;
+            const target = targets[service.entrypoint ?? "default"];
+            if (!target)
+                throw new Error(`Binding ${service.binding} refers to an unknown Worker entrypoint ${service.entrypoint}.`);
+            result[service.binding] = target.methods;
+        }
+        return result;
+    }
+    function signature(role) {
+        const targets = role === "main" ? contracts.main : nativeContracts();
+        return JSON.stringify({ bindings: bindings(role), methods: Object.entries(targets).map(([name, value]) => [name, value.methods]) });
+    }
+    function refresh() {
+        const source = serviceEntrypoint(entry, contracts.services());
+        writeChanged(generated, `${source}import { eventEntrypoint } from ${JSON.stringify(events)};
+export const TokamakEvents = eventEntrypoint(Worker, nativeContext);\n`);
+        writeChanged(path.join(output, "methods.json"), `${JSON.stringify(contracts.native.methods)}\n`);
+    }
+    const configure = (config) => {
+        if (!config.name)
+            throw new Error("Tokamak requires a name in the main Worker's configuration.");
+        const reserved = new Set(["MAIN", "TOKAMAK_RUNTIME", ...services(config.name).map(service => service.binding)]);
+        const collision = bindingNames(config).find(name => reserved.has(name));
+        if (collision) {
+            throw new Error(`${collision} is reserved for a generated native worker binding.`);
+        }
+        mainName = config.name;
+        nativeName = workerName(mainName);
+        appName = config.topLevelName ?? mainName;
+        contracts.configure(config);
+        if (dev)
+            config.main = serviceModule("main");
+        config.services = [...config.services ?? [], ...services(mainName)];
+        mainServices = config.services;
+        configuredEntrypoints = entrypoints();
+    };
+    const native = (_config, { entryWorkerConfig }) => {
+        if (!mainName)
+            throw new Error("The main Worker must be configured before the Tokamak worker.");
+        contracts.bindings(entryWorkerConfig);
+        const { configPath, userConfigPath, compatibility_date, compatibility_flags, vars, kv_namespaces, d1_databases, r2_buckets } = entryWorkerConfig;
+        return {
+            configPath,
+            userConfigPath,
+            name: nativeName,
+            main: dev ? serviceModule("native") : generated,
+            compatibility_date,
+            compatibility_flags,
+            vars,
+            kv_namespaces,
+            d1_databases,
+            r2_buckets,
+            services: [{ binding: "MAIN", service: mainName }],
+        };
+    };
+    refresh();
+    return {
+        generated: normalizePath(generated),
+        relay(port, token, platform) { relay = { port, token, platform }; },
+        availability: () => availability(contracts.plugins),
+        configure,
+        services,
+        native,
+        names: () => ({ main: mainName, native: nativeName, app: appName }),
+        contract: () => contracts.native,
+        types: contracts,
+        cloudflare: {
+            config: configure,
+            auxiliaryWorkers: [{
+                    viteEnvironment: { name: "tokamak" },
+                    config: native,
+                }],
+        },
+        plugin: {
+            name: "tokamak:worker-graph",
+            config(_config, environment) {
+                dev = environment.command === "serve";
+                contracts.discover();
+            },
+            // After Cloudflare's plugin, which points each Worker's dependency scan
+            // at its main. The scan cannot read a development service module, so it
+            // reads the app's module behind it, and finds that module's dependencies
+            // at startup rather than reloading the Worker when they are first
+            // imported.
+            configEnvironment: {
+                order: "post",
+                handler(name, config) {
+                    const scanned = [config.optimizeDeps?.entries ?? []].flat();
+                    const served = [
+                        scanned.includes(serviceModule("main")) && contracts.mainEntry,
+                        scanned.includes(serviceModule("native")) && entry,
+                    ].filter(module => typeof module === "string").map(normalizePath);
+                    // The main Worker's entry is the app, not a dependency, and the
+                    // plugin SDK keeps state that a dependency bundle would copy.
+                    const exclude = [contracts.mainEntry, name === "tokamak" && "@tokamakdev/plugin"]
+                        .filter(module => typeof module === "string");
+                    return { optimizeDeps: { entries: served, exclude } };
+                },
+            },
+            async buildStart() {
+                if (this.environment.name !== "tokamak")
+                    return;
+                for (const file of contracts.metadata)
+                    this.addWatchFile(file);
+                await contracts.resolve(id => this.resolve(id, undefined, { skipSelf: true }));
+                refresh();
+                for (const file of sources())
+                    this.addWatchFile(file);
+            },
+            hotUpdate({ file, modules, timestamp }) {
+                if (file === normalizePath(types))
+                    return;
+                if (contracts.metadata.includes(file))
+                    return [];
+                const role = this.environment.name === "tokamak" ? "native"
+                    : this.environment.name === mainEnvironment ? "main" : undefined;
+                if (!role)
+                    return;
+                if (!sources().includes(file) && (this.environment.name !== "tokamak" || !modules.length))
+                    return;
+                contracts.refresh({ file, timestamp });
+                refresh();
+                if (entrypoints() !== configuredEntrypoints) {
+                    this.environment.logger.warnOnce("Restart tok dev after adding, removing, or renaming a Tokamak entrypoint.");
+                }
+                if (!modules.length && signatures.get(role) === signature(role))
+                    return;
+                this.environment.moduleGraph.invalidateAll();
+                this.environment.hot.send({ type: "full-reload" });
+                return [];
+            },
+            resolveId(id) {
+                if (id === NATIVE_CONNECTION)
+                    return `\0${NATIVE_CONNECTION}`;
+                if (id.startsWith("\0tokamak:") || id.startsWith("\0virtual:tokamak/"))
+                    return id;
+                const role = id === serviceModule("native") ? "native" : id === serviceModule("main") ? "main" : undefined;
+                if (!role)
+                    return;
+                return `\0${serviceModule(role)}`;
+            },
+            async load(id) {
+                if (id === `\0${NATIVE_CONNECTION}`)
+                    return nativeConnectionModule(dev ? relay : undefined);
+                const role = id.endsWith(":main") || id.endsWith("/main") ? "main" : "native";
+                if (id !== bindingsModule(role) && id !== `\0${serviceModule(role)}`)
+                    return;
+                await contracts.resolve(source => this.resolve(source, undefined, { skipSelf: true }));
+                refresh();
+                if (role === "main")
+                    mainEnvironment = this.environment.name;
+                if (id === bindingsModule(role)) {
+                    return `import { env } from "cloudflare:workers";
+import { installBindings } from ${JSON.stringify(development)};
+installBindings(env, ${JSON.stringify(bindings(role))});`;
+                }
+                signatures.set(role, signature(role));
+                const source = JSON.stringify(role === "main" ? contracts.mainModule : normalizePath(generated));
+                const targets = role === "main" ? contracts.main : nativeContracts();
+                const exports = Object.entries(targets).map(([name, value], index) => `const Service${index} = developmentEntrypoint(module[${JSON.stringify(name)}], ${JSON.stringify(value.methods)}, ${JSON.stringify(bindings(role))});
+export { Service${index} as ${JSON.stringify(name)} };`);
+                const hostEvents = role === "native"
+                    ? `export const TokamakEvents = developmentEvents(module.TokamakEvents, ${JSON.stringify(bindings(role))});`
+                    : "";
+                return `import ${JSON.stringify(bindingsModule(role))};
+import * as module from ${source};
+export * from ${source};
+import { developmentEntrypoint, developmentEvents } from ${JSON.stringify(development)};
+${exports.join("\n")}
+${hostEvents}`;
+            },
+        },
+    };
+}
+/** The binding kinds of a Worker configuration besides variables, whose entries name bindings. */
+const BINDING_KINDS = [
+    "ai", "analytics_engine_datasets", "assets", "browser", "d1_databases", "dispatch_namespaces", "durable_objects",
+    "hyperdrive", "images", "kv_namespaces", "mtls_certificates", "pipelines", "queues", "r2_buckets", "rate_limiting",
+    "secrets_store_secrets", "send_email", "services", "vectorize", "version_metadata", "workflows",
+];
+/** Every binding name `config` declares, as the native packager reads them. */
+function bindingNames(config) {
+    const names = Object.keys(config.vars ?? {});
+    const collect = (value) => {
+        if (Array.isArray(value))
+            return value.forEach(collect);
+        if (!value || typeof value !== "object")
+            return;
+        const entry = value;
+        const nested = ["bindings", "producers", "consumers"].filter(key => key in entry);
+        if (nested.length)
+            return nested.forEach(key => { collect(entry[key]); });
+        const name = ["binding", "name", "queue", "dataset"].map(key => entry[key]).find(name => typeof name === "string");
+        if (typeof name === "string")
+            names.push(name);
+    };
+    for (const kind of BINDING_KINDS)
+        collect(config[kind]);
+    return names;
+}
+export function workerName(main) {
+    const name = `${main}-tokamak`;
+    if (name.length <= 63)
+        return name;
+    return `${main.slice(0, 46)}-${createHash("sha256").update(main).digest("hex").slice(0, 8)}-tokamak`;
+}
+/**
+ * The module whose `connect(ctx)` gives an invocation its native connection: the device relay
+ * during development, otherwise none, so the context uses the connection the host attached.
+ */
+function nativeConnectionModule(relay) {
+    if (!relay)
+        return "export const connect = () => undefined;";
+    return `import { connectDevice } from ${JSON.stringify(NATIVE_CALLS)};
+export const connect = ctx => connectDevice(${String(relay.port)}, ${JSON.stringify(relay.token)}, ctx, ${JSON.stringify(relay.platform ?? null)} ?? undefined);`;
+}
+/** Each plugin operation's native platforms: those its manifest names, or every one the plugin builds for. */
+function availability(plugins) {
+    return Object.fromEntries(plugins.map(({ definition, operations }) => [
+        definition.id,
+        Object.fromEntries(operations.map(operation => [
+            operation,
+            definition.operations[operation]?.platforms.map(({ name }) => name) ?? definition.platforms,
+        ])),
+    ]));
+}
+function serviceEntrypoint(entry, services) {
+    const sdk = normalizePath(fileURLToPath(import.meta.resolve("@tokamakdev/plugin/worker")));
+    const rpc = normalizePath(fileURLToPath(new URL("./rpc/endpoint.mjs", import.meta.resolve("@tokamakdev/plugin/events"))));
+    const plugins = services.flatMap(service => service.plugin ? [service.plugin] : []);
+    const imports = services.map((service, index) => {
+        if (service.plugin) {
+            const { api } = service.plugin.definition;
+            return `import { ${JSON.stringify(api.export)} as Service${index} } from ${JSON.stringify(api.module)};`;
+        }
+        if (!entry)
+            return `import { TokamakEntrypoint as Service${index} } from ${JSON.stringify(sdk)};`;
+        const name = service.entrypoint === "default" ? "default" : JSON.stringify(service.entrypoint);
+        return `import { ${name} as Service${index} } from ${JSON.stringify(normalizePath(entry))};`;
+    });
+    const table = services.map((service, index) => `  { route: ${JSON.stringify(service.route)}, methods: ${JSON.stringify(service.contract.methods)}, create: ${service.plugin
+        ? `ctx => Service${index}(nativeContext(ctx))`
+        : `(ctx, env) => new Service${index}(nativeContext(ctx), env)`} },`);
+    const methods = (methods, instance) => methods.map(method => `async [${JSON.stringify(method)}](...args) { return this.${instance}[${JSON.stringify(method)}](...args); }`).join("\n  ");
+    const named = services.slice(1).map((service, index) => `
+export class ${service.entrypoint} extends WorkerEntrypoint {
+  #api;
+  get #instance() { return this.#api ??= services[${index + 1}].create(this.ctx, this.env); }
+  fetch(request) {
+    ${service.plugin
+        ? `return rpcResponse(request, ctx => services[${index + 1}].create(ctx, this.env), services[${index + 1}].methods, this.ctx);`
+        : `if (typeof this.#instance.fetch !== "function") throw new TypeError("The ${service.entrypoint} entrypoint has no fetch handler");
+    return this.#instance.fetch(request);`}
+  }
+  ${methods(service.contract.methods, "#instance")}
+}
+`);
+    return `import { WorkerEntrypoint } from "cloudflare:workers";
+import { rpcResponse } from ${JSON.stringify(rpc)};
+import { capabilitiesModule, createNativeContext } from ${JSON.stringify(sdk)};
+import { connect } from ${JSON.stringify(NATIVE_CONNECTION)};
+${imports.join("\n")}
+
+const availability = ${JSON.stringify(availability(plugins))};
+const nativeContext = ctx => createNativeContext(ctx, connect(ctx), availability);
+const services = [
+${table.join("\n")}
+];
+const Worker = Service0;
+
+export default class extends WorkerEntrypoint {
+  #worker;
+  get #instance() { return this.#worker ??= services[0].create(this.ctx, this.env); }
+  fetch(request) {
+    const { pathname } = new URL(request.url);
+    if (pathname === "/_tokamak/capabilities.js") return capabilitiesModule(nativeContext(this.ctx));
+    const service = services.find(service => service.route === pathname);
+    if (service) return rpcResponse(request, ctx => service.create(ctx, this.env), service.methods, this.ctx);
+    if (typeof this.#instance.fetch !== "function") throw new TypeError("The Tokamak worker has no fetch handler");
+    return this.#instance.fetch(request);
+  }
+  ${methods(services[0]?.contract.methods ?? [], "#instance")}
+}
+${named.join("")}
+`;
+}
+function writeChanged(file, source) {
+    if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === source)
+        return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, source);
+}

package/dist/worker-types.d.mts

@@ -0,0 +1,46 @@
+import type { PluginConfig } from "@cloudflare/vite-plugin";
+import { type PluginContract, type WorkerContract } from "./worker-contract.mjs";
+import { type PluginDefinition } from "./plugin-manifest.mjs";
+type MainCustomizer = Extract<NonNullable<PluginConfig["config"]>, (...args: never[]) => unknown>;
+export type WorkerConfiguration = Parameters<MainCustomizer>[0];
+export type BindingConfiguration = Partial<Pick<WorkerConfiguration, "main" | "configPath" | "vars" | "kv_namespaces" | "d1_databases" | "r2_buckets">>;
+/** A generated binding to an entrypoint of the Tokamak worker, and the page client of its operations. */
+export interface NativeService {
+    binding: string;
+    /** The entrypoint's export name in the generated Tokamak worker. */
+    entrypoint: string;
+    client: string;
+    /** The frontend RPC route. */
+    route: string;
+    contract: WorkerContract;
+    plugin?: PluginContract;
+}
+/** Shared contracts for the two entrypoints and their generated callers. */
+export declare class WorkerTypes {
+    #private;
+    readonly root: string;
+    readonly entry: string | undefined;
+    native: WorkerContract;
+    /** The Tokamak worker's named entrypoints. */
+    named: Record<string, WorkerContract>;
+    main: Record<string, WorkerContract>;
+    plugins: PluginContract[];
+    definitions: PluginDefinition[];
+    mainEntry?: string;
+    mainModule?: string;
+    constructor(root: string, entry: string | undefined);
+    configure(config: BindingConfiguration): void;
+    bindings(config: BindingConfiguration): void;
+    resolve(resolve: (id: string) => Promise<{
+        id: string;
+    } | null>): Promise<void>;
+    discover(): void;
+    /** Every generated binding to the Tokamak worker: the app's entrypoints, then the plugins'. */
+    services(): NativeService[];
+    get metadata(): string[];
+    refresh(change?: {
+        file: string;
+        timestamp: number;
+    }): void;
+}
+export {};

package/dist/worker-types.mjs

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readWorkerContracts } from "./worker-contract.mjs";
+import { serviceTypes, writeEnvironmentTypes } from "./service-types.mjs";
+import { discoverPlugins } from "./plugin-manifest.mjs";
+/** Shared contracts for the two entrypoints and their generated callers. */
+export class WorkerTypes {
+    root;
+    entry;
+    native = { methods: [], files: [], declarations: serviceTypes("{}", []) };
+    /** The Tokamak worker's named entrypoints. */
+    named = {};
+    main = {};
+    plugins = [];
+    definitions;
+    mainEntry;
+    mainModule;
+    #bindings = [];
+    #ready = false;
+    #change;
+    constructor(root, entry) {
+        this.root = root;
+        this.entry = entry;
+        this.definitions = discoverPlugins(root);
+    }
+    configure(config) {
+        if (!config.main)
+            throw new Error("Tokamak requires a main Worker entrypoint.");
+        const source = path.resolve(config.configPath ? path.dirname(config.configPath) : this.root, config.main);
+        this.mainEntry = fs.existsSync(source) ? source : config.main;
+        this.mainModule = undefined;
+        this.#ready = false;
+        this.bindings(config);
+    }
+    bindings(config) {
+        this.#ready = false;
+        this.#bindings = [...new Set([
+                ...Object.keys(config.vars ?? {}),
+                ...[...config.kv_namespaces ?? [], ...config.d1_databases ?? [], ...config.r2_buckets ?? []].map(value => value.binding),
+            ])].sort();
+    }
+    async resolve(resolve) {
+        if (this.#ready)
+            return;
+        if (this.mainEntry && !this.mainModule) {
+            const resolved = await resolve(this.mainEntry);
+            const source = resolved?.id.split(/[?#]/, 1)[0];
+            if (!source || !fs.existsSync(source)) {
+                throw new Error(`Cannot resolve the main Worker's service contract: ${this.mainEntry} (${resolved?.id ?? "unresolved"}).`);
+            }
+            this.mainModule = source.split(path.sep).join("/");
+        }
+        this.refresh();
+    }
+    discover() {
+        const definitions = discoverPlugins(this.root);
+        if (definitions.length !== this.definitions.length || definitions.some((plugin, index) => plugin.id !== this.definitions[index].id || plugin.package !== this.definitions[index].package)) {
+            throw new Error("Restart tok dev after installing, removing, or renaming a Tokamak plugin.");
+        }
+        this.definitions = definitions;
+        this.#read(false);
+    }
+    /** Every generated binding to the Tokamak worker: the app's entrypoints, then the plugins'. */
+    services() {
+        const services = [
+            { binding: "TOKAMAK", entrypoint: "default", client: "virtual:tokamak/client", route: "/_tokamak/app", contract: this.native },
+            ...Object.entries(this.named).map(([name, contract]) => ({
+                binding: `TOKAMAK_${constantCase(name)}`, entrypoint: name, client: `virtual:tokamak/client/${name}`,
+                route: `/_tokamak/app/${name}`, contract,
+            })),
+            ...this.plugins.map(plugin => ({
+                binding: plugin.definition.binding, entrypoint: plugin.definition.binding, client: plugin.definition.client,
+                route: `/_tokamak/plugin/${plugin.definition.id}`, contract: plugin, plugin,
+            })),
+        ];
+        const bindings = new Set();
+        for (const { binding, entrypoint } of services) {
+            if (bindings.has(binding))
+                throw new Error(`The generated binding ${binding} of entrypoint ${entrypoint} has the name of another.`);
+            bindings.add(binding);
+        }
+        return services;
+    }
+    get metadata() {
+        return [path.join(this.root, "package.json"), ...this.definitions.map(plugin => plugin.manifest)]
+            .map(file => file.split(path.sep).join("/"));
+    }
+    refresh(change) {
+        if (this.mainEntry && !this.mainModule)
+            return;
+        if (this.#ready && change && change.file === this.#change?.file && change.timestamp === this.#change.timestamp)
+            return;
+        this.#ready = false;
+        this.discover();
+        // Declare both APIs before checking signatures inferred from cross-worker calls.
+        writeEnvironmentTypes(this.root, this.services(), this.main.default?.declarations ?? serviceTypes("{}", [], "Main"), this.#bindings);
+        this.#read(true);
+        this.#ready = true;
+        this.#change = change;
+    }
+    #read(validate) {
+        const contracts = readWorkerContracts(this.entry, this.mainModule, this.root, validate, this.definitions);
+        this.native = contracts.native;
+        this.named = contracts.named;
+        this.main = contracts.main;
+        this.plugins = contracts.plugins;
+    }
+}
+/** `name` in upper case with words joined by underscores: `DataSync` becomes `DATA_SYNC`. */
+function constantCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/tok",
-  "version": "0.1.1-beta.106",
+  "version": "0.1.1-beta.112",
   "description": "The tokamak CLI, Vite plugin and app API: build native apps from a Cloudflare Workers codebase",
   "repository": {
     "type": "git",
@@ -19,6 +19,10 @@
     "./vite": {
       "types": "./dist/vite.d.mts",
       "default": "./dist/vite.mjs"
+    },
+    "./astro": {
+      "types": "./dist/astro.d.mts",
+      "default": "./dist/astro.mjs"
     }
   },
   "bin": {
@@ -33,22 +37,28 @@
   "scripts": {
     "build": "tsc",
     "prepack": "npm run build",
-    "test": "node --test"
+    "test": "node --test --test-concurrency=1"
   },
   "engines": {
     "node": ">=18"
   },
   "dependencies": {
-    "@tokamakdev/plugin": "0.1.0-beta.106",
+    "@tokamakdev/plugin": "0.1.0-beta.112",
+    "typescript": "5.9.3",
     "ws": "^8.22.0"
   },
   "peerDependencies": {
+    "@astrojs/cloudflare": "^13.1.8",
     "@cloudflare/vite-plugin": "^1.54.0",
+    "astro": "^6.1.5",
     "vite": "^7.0.0 || ^8.0.0",
     "wrangler": "^4.126.0"
   },
   "peerDependenciesMeta": {
-    "@cloudflare/vite-plugin": {
+    "@astrojs/cloudflare": {
+      "optional": true
+    },
+    "astro": {
       "optional": true
     },
     "wrangler": {
@@ -56,25 +66,26 @@
     }
   },
   "devDependencies": {
+    "@astrojs/cloudflare": "13.1.8",
     "@cloudflare/vite-plugin": "1.62.5",
     "@types/node": "22.19.15",
     "@types/ws": "8.18.2",
-    "typescript": "5.9.3",
-    "vite": "8.3.2",
+    "astro": "6.1.5",
+    "vite": "7.3.7",
     "wrangler": "4.147.0"
   },
   "optionalDependencies": {
-    "@tokamakdev/platform-android-arm64": "0.1.1-beta.106",
-    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.106",
-    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.106",
-    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.106",
-    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.106",
-    "@tokamakdev/platform-macos-x64": "0.1.1-beta.106",
-    "@tokamakdev/platform-windows-x64": "0.1.1-beta.106",
-    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.106",
-    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.106",
-    "@tokamakdev/tok-linux-x64": "0.1.1-beta.106",
-    "@tokamakdev/tok-win32-x64": "0.1.1-beta.106"
+    "@tokamakdev/platform-android-arm64": "0.1.1-beta.112",
+    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.112",
+    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.112",
+    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.112",
+    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.112",
+    "@tokamakdev/platform-macos-x64": "0.1.1-beta.112",
+    "@tokamakdev/platform-windows-x64": "0.1.1-beta.112",
+    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.112",
+    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.112",
+    "@tokamakdev/tok-linux-x64": "0.1.1-beta.112",
+    "@tokamakdev/tok-win32-x64": "0.1.1-beta.112"
   },
   "publishConfig": {
     "access": "public"