void 0.26.1 → 0.28.0

package/dist/{ws-CChrrAU-.d.mts → ws-aKVYB-fA.d.mts}

@@ -1,6 +1,6 @@
 import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
 import { r as AuthUser } from "./auth-DkcFflXV.mjs";
-import { a as CloudEnv } from "./handler-CNAwjRcW.mjs";
+import { a as CloudEnv } from "./handler-_PqY82xe.mjs";
 import { WebSocketRouteMap } from "void/routes";
 //#region src/runtime/ws.d.ts
 type MaybePromise<T> = T | Promise<T>;

package/dist/yarn-pnp-DLbEFMT0.mjs

@@ -0,0 +1,92 @@
+import { a as join, n as dirname } from "./dist-ipQi0Q8y.mjs";
+import { existsSync, readdirSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/cli/yarn-pnp.ts
+const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+/** Read the PnP runtime files in `dir` only, or `undefined` when neither exists. */
+function readPnpRuntimeAt(dir) {
+	const cjs = join(dir, ".pnp.cjs");
+	const loader = join(dir, ".pnp.loader.mjs");
+	const cjsExists = existsSync(cjs);
+	const loaderExists = existsSync(loader);
+	if (!cjsExists && !loaderExists) return;
+	return {
+		pnpCjs: cjsExists ? cjs : void 0,
+		pnpLoader: loaderExists ? loader : void 0
+	};
+}
+/**
+* Whether `dir` has its own package-manager lockfile, i.e. it is an install
+* root: workspace members share the root lockfile. `packageManager` is not a
+* signal, because a Yarn workspace member may pin it and still resolve through
+* the root's `.pnp.cjs`.
+*/
+function hasLocalLockfile(dir) {
+	return existsSync(join(dir, "pnpm-lock.yaml")) || existsSync(join(dir, "package-lock.json")) || existsSync(join(dir, "yarn.lock")) || existsSync(join(dir, "bun.lock")) || existsSync(join(dir, "bun.lockb"));
+}
+/**
+* Find Yarn Berry PnP runtime files at `start` or its nearest ancestor, since a
+* monorepo keeps `.pnp.cjs` at the workspace root. A lockfile at `start` stops
+* the walk: an outer PnP graph lacks the local install's dependencies.
+*/
+function findYarnPnpRuntime(start) {
+	const local = readPnpRuntimeAt(start);
+	if (local !== void 0) return {
+		dir: start,
+		runtime: local
+	};
+	if (hasLocalLockfile(start)) return;
+	let dir = dirname(start);
+	if (dir === start) return;
+	while (true) {
+		const found = readPnpRuntimeAt(dir);
+		if (found !== void 0) return {
+			dir,
+			runtime: found
+		};
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+/**
+* Like {@link findYarnPnpRuntime}, but only when Yarn has installed into that
+* same directory. A committed `.pnp.cjs` alone does not prove an install: its
+* ZIP archives may not be fetched yet.
+*/
+function findInstalledYarnPnpRuntime(start) {
+	const found = findYarnPnpRuntime(start);
+	return found && isYarnPnpInstalled(found.dir) ? found.runtime : void 0;
+}
+/**
+* Yarn writes `.yarn/install-state.gz` on every install; a zero-install
+* checkout instead commits a populated `.yarn/cache`.
+*/
+function isYarnPnpInstalled(dir) {
+	if (existsSync(join(dir, ".yarn", "install-state.gz"))) return true;
+	const cacheDir = join(dir, ".yarn", "cache");
+	if (!existsSync(cacheDir)) return false;
+	try {
+		return readdirSync(cacheDir).some((e) => e.endsWith(".zip"));
+	} catch {
+		return false;
+	}
+}
+/**
+* Build a child env that loads the Yarn PnP runtime found at or above `root`,
+* like `yarn node` does. Existing `NODE_OPTIONS` go after our flags so the PnP
+* `--require` patches resolution first.
+*/
+function buildDrizzleKitSpawnEnv(root) {
+	const env = { ...process.env };
+	const pnp = findYarnPnpRuntime(root)?.runtime;
+	if (!pnp) return env;
+	const flags = [];
+	if (pnp.pnpCjs) flags.push(`--require ${JSON.stringify(pnp.pnpCjs)}`);
+	if (pnp.pnpLoader) flags.push(`--experimental-loader ${pathToFileURL(pnp.pnpLoader).href}`);
+	const injected = flags.join(" ");
+	env.NODE_OPTIONS = process.env.NODE_OPTIONS ? `${injected} ${process.env.NODE_OPTIONS}` : injected;
+	return env;
+}
+//#endregion
+export { hasLocalLockfile as i, drizzleKitBin as n, findInstalledYarnPnpRuntime as r, buildDrizzleKitSpawnEnv as t };

package/docs/guide/auth.md

@@ -127,6 +127,8 @@ Auth sessions use the same database as your app. Void creates `BETTER_AUTH_SECRE
 
 Local development needs no secret setup. To preview a production build locally, provide `BETTER_AUTH_SECRET`.
 
+Responses to signed-in requests get `Cache-Control: no-store`, so neither the browser cache nor a shared cache keeps a user's data. A route keeps its own policy when it sets `no-store`, or `private` together with `no-cache`. To answer repeat requests with `304`, use `private, no-cache` with Hono's [`etag()`](https://hono.dev/docs/middleware/builtin/etag) middleware. If you set the `ETag` yourself, make it differ per user, so the `304` doesn't reuse another account's page. The browser cache keeps a copy of a `private, no-cache` page, so the Back button can show it again after the user signs out. Keep the default `no-store` for pages that must not stay in the browser cache.
+
 `POST`, `PUT`, `PATCH` and `DELETE` requests and WebSocket connections from another origin don't use the signed-in session unless that origin is in `trustedOrigins`. If a separate frontend calls your app, add its origin there (see [Customization](#customization)). If your routes use their own cookies, check the request `Origin` yourself, for example with Hono's [`csrf()`](https://hono.dev/docs/middleware/builtin/csrf) middleware.
 
 Deployed apps on Cloudflare limit auth requests per client IP with Better Auth's defaults, for example 3 sign-in attempts per 10 seconds. Each Worker instance keeps its own count. Change or turn off the limits with `rateLimit` in `auth.ts`. To share one count across instances, set `rateLimit: { storage: 'database' }`, then run `void db generate` for a direct Cloudflare deploy.

package/docs/guide/database/postgresql.md

@@ -40,6 +40,8 @@ For a Void platform, deploy prompts for the connection string if needed. You can
 
 Void provisions Hyperdrive without saving the connection string in project config. Both `postgres://` and `postgresql://` URLs are supported, including provider query strings such as `?sslmode=require`.
 
+The Hyperdrive that Void creates connects with TLS in Cloudflare's default `require` mode. Hyperdrive does not use the `sslmode=verify-ca`, `sslmode=verify-full`, or `sslrootcert` settings from your connection string. To have Hyperdrive verify your database against a specific certificate authority on a direct Cloudflare deploy, [create the Hyperdrive in Cloudflare with that certificate](https://developers.cloudflare.com/hyperdrive/configuration/tls-ssl-certificates-for-hyperdrive/) and add its ID to [`cloudflare.hyperdrive`](../../integrations/cloudflare.md#databases-and-secrets).
+
 ## Schema Definition
 
 Import schema helpers from `void/schema-pg`:

package/docs/guide/database.md

@@ -47,6 +47,8 @@ Choose a database during `void init`, or set `database` in `void.config.ts`:
 | Managed by | Void                         | Bring your own database             | Bring your own database   |
 | Connection | Automatic D1 binding         | Hyperdrive                          | Hyperdrive                |
 
+A Void platform keeps Hyperdrive query caching off for your database connection, so reads reflect completed writes. An existing connection is updated on the project's next deploy.
+
 ## Schema Definition
 
 Define your tables in `db/schema.ts` using column helpers from `void/schema-d1`, `void/schema-pg`, or `void/schema-mysql`.

package/docs/guide/deployment.md

@@ -73,7 +73,7 @@ If CI runs typechecking before deploy, run `void prepare` after installing depen
 Use the API URL from your administrator. In a new or unlinked app:
 
 ```sh
-void connect https://platform.example.com
+void connect platform.example.com
 void deploy --platform void --project my-app
 ```
 
@@ -86,7 +86,7 @@ Project owners can [share access](./project-collaboration.md). To install a plat
 For a single deployment to a different platform, connect and name its project:
 
 ```sh
-void connect https://second.example.com
+void connect second.example.com
 VOID_API_URL=https://second.example.com void deploy --platform void --project my-app
 ```
 

package/docs/guide/durable-state.md

@@ -163,3 +163,27 @@ Typed state works in local development and direct Cloudflare deploys of native V
 Custom Durable Object modules are not supported on Void platforms, in meta-frameworks, or on Node.js, Bun, and Deno.
 
 This is separate from [typed WebSocket routes](./websockets.md), which also use SQLite-backed Durable Objects and work on both direct Cloudflare and hosted Void deployments.
+
+## Native Durable Object classes
+
+Use `defineDurableObject` to keep a native Cloudflare class, including classes extending Cloudflare Agents. Void discovers its binding and exports the class without replacing its constructor, lifecycle, or RPC methods. Like Durable State, this supports direct Cloudflare deployments.
+
+```ts
+// durable-objects/workspace.ts
+import { DurableObject } from 'cloudflare:workers';
+import { defineDurableObject } from 'void/durable';
+
+class WorkspaceObject extends DurableObject {
+  async fetch() {
+    return new Response('Workspace');
+  }
+}
+
+export const Workspace = defineDurableObject({
+  name: 'workspace',
+  class: WorkspaceObject,
+});
+export default Workspace;
+```
+
+Call `Workspace.get('project-id')` from a server handler to obtain its typed stub. Keep the resource name and instance name stable across deployments to retain storage.

package/docs/guide/platform/administration/access.md

@@ -11,7 +11,7 @@ For the browser admin UI, open `<API URL>/admin` and use the administrator login
 Connect to your platform's API URL, then sign in as an administrator:
 
 ```sh
-void connect https://platform.example.com --no-login
+void connect platform.example.com --no-login
 void platform auth login
 ```
 
@@ -158,3 +158,7 @@ Invitation history remains available after an involved account is removed. The s
 remains visible when that account's login no longer exists.
 
 `void platform signup open` allows anyone to sign up. Everyone who signs up can deploy apps on your application domain, so check how those apps [share cookies](/guide/platform/installation/domains#adding-a-domain) before opening signup. Use `void platform signup restrict` to require an allowlist match again. Disallowing an entry affects future signup; it does not suspend an existing account.
+
+## Connected apps
+
+Register separate applications as OAuth clients through [Connected apps](./connected-apps.md). Users connect their identity and approve each publish on Void.

package/docs/guide/platform/administration/connected-apps.md

@@ -0,0 +1,55 @@
+# Connected apps
+
+A connected app is a separate application registered as an OAuth client on your Void installation. Users sign in on Void and decide whether to connect it. The application operator may be different from the platform administrator.
+
+## Register an application
+
+Open **Admin → Connected apps**. Enter the app name, its operator, and each exact HTTPS callback URL on a separate line. Wildcards and callback query strings are not supported. Enable individual publish approvals if the app builds and deploys projects.
+
+Save the returned client ID and secret on the app's server. Void shows the secret once. The client secret authenticates that application; it does not grant access to users' accounts. Register a new client if you need replacement credentials, then disable the old one.
+
+**Disable and revoke access** invalidates the client's grants, pending sign-ins, and publish approvals. Registration and disablement appear in the operator audit.
+
+Local development permits exact HTTP callbacks on localhost when the platform's development authentication bypass is explicitly enabled. Production clients require HTTPS.
+
+## Connect and disconnect
+
+The app sends users to Void's authorization page, where Void displays its registered name, operator, callback origin, and requested permission. Sign-in permits reading the user's ID and username. It does not provide an account token or project management access.
+
+Users can disconnect applications at `<platform API URL>/oauth/connections`. Grants also expire after an hour and become invalid when their platform login session is revoked or their account is suspended. Applications must request a new sign-in when access expires.
+
+## Approve a publish
+
+The app builds first, then sends the user to Void with the prepared artifact. Void displays the project name, checkpoint label, resources, manifest, and artifact digest. The user must explicitly approve on Void.
+
+Approval permits one deployment to that user's chosen project. Void creates a missing project during approval; existing projects require ownership. The app receives a credential valid for up to fifteen minutes, restricted to that artifact's asset uploads, deployment, and receipt. Retries use the same receipt.
+
+Published code can use that project's existing secrets and resources. Review the app operator and deployment details before approving code for an existing project. Migrations and resource changes in the approved manifest take effect during deployment.
+
+Disabling the app or disconnecting its grant stops authorization for subsequent actions and is checked again before a queued deployment publishes. Disconnecting does not remove an app that has already been published; manage that project through Void.
+
+## Build an OAuth client
+
+Discover endpoints at `/.well-known/oauth-authorization-server` on the platform API origin. Use authorization code flow with `scope=profile`, a random `state`, and S256 PKCE. Authenticate token exchanges using HTTP Basic client authentication. Send access tokens as Bearer credentials to `/oauth/userinfo`; its response contains `sub` and `preferred_username`.
+
+For publishing, package the built app with [`prepareDeployArtifact`](/reference/api/deploy). POST to `/oauth/deployment-requests` using the profile token:
+
+```ts
+{
+  redirect_uri: registeredCallback,
+  state: publishState,
+  code_challenge: publishChallenge,
+  code_challenge_method: 'S256',
+  slug: projectSlug,
+  checkpoint: checkpointLabel,
+  artifact: prepared.artifact
+}
+```
+
+Redirect the browser to the returned `authorization_url`. Exchange its code with the publish verifier and the same registered callback. The response includes `project_id`, `approval_id`, and a `deploy:approve` access token. This publish flow is a Void extension; requesting that scope in an ordinary sign-in does not authorize deployment.
+
+Use the token to request URLs from `POST /projects/:id/deploy/upload-urls`, upload the declared assets, and send the artifact to `POST /projects/:id/deploy`. Set `x-void-deploy-idempotency-key` to `approval_id`. Deployment uses Void's managed deployment protocol and requires the platform deployment Queue. The credential cannot read secrets, mint project tokens, delete projects, or deploy different bytes.
+
+Revoke identity grants with `POST /oauth/revoke`, authenticated as the client. No refresh token or OpenID Connect ID token is issued.
+
+If the API is protected by Cloudflare Access, the application operator must also configure a service identity permitted by that Access application's policy. Server OAuth endpoints and approved deployment requests still validate their own client, grant, and project authority; browser consent requires the user's company identity.

package/docs/guide/platform/installation/credentials.md

@@ -39,6 +39,8 @@ Use the following permissions for the core platform. Cloudflare may label write
 | Account | Hyperdrive         | Write      | Write                                   |
 | Account | Account Analytics  | Read       | Read                                    |
 | Account | AI Gateway         | Edit       | Edit when installing with browser login |
+| Account | Containers         | —          | Edit                                    |
+| Account | Cloudchamber       | —          | Edit                                    |
 | Zone    | Zone               | Read       | —                                       |
 | Zone    | DNS                | Edit       | —                                       |
 | Zone    | Workers Routes     | Edit       | —                                       |
@@ -72,7 +74,7 @@ The installer deploys the email gateway, prepares the shared mail route, and ver
 
 ## R2 Upload Credentials
 
-In the **R2 token creation** form opened by the installer, select **Object Read & Write** and **Apply to all buckets in this account (including newly created buckets)**. Create an account token, or a user token if your role requires it. Save its **Access Key ID** and **Secret Access Key** in your password manager. These differ from the management and runtime API tokens. See [R2’s token instructions](https://developers.cloudflare.com/r2/api/tokens/).
+The installer opens the **R2 token creation** form with a token name based on your platform's display name, **Object Read & Write**, and **Apply to all buckets in this account (including newly created buckets)** preselected. Review the settings and create an account token, or a user token if your role requires it. Save its **Access Key ID** and **Secret Access Key** in your password manager, then paste both into the installer. These differ from the management and runtime API tokens. See [R2’s token instructions](https://developers.cloudflare.com/r2/api/tokens/).
 
 ## Signing and Encryption Keys {#signing-and-encryption-keys}
 

package/docs/guide/platform/installation/first-deployment.md

@@ -17,7 +17,7 @@ void platform system health
 Administrator login is separate from the credentials used to deploy apps. In a new or unlinked Void app directory, connect using the installed API URL and deploy your first project:
 
 ```sh
-void connect https://void-company-api.example.workers.dev
+void connect void-company-api.example.workers.dev
 void deploy --platform void --project my-first-app
 ```
 

package/docs/guide/project-collaboration.md

@@ -54,7 +54,7 @@ Connect to the platform from your invitation, then see invitations addressed to
 your account and respond using the invitation ID:
 
 ```sh
-void connect https://api.example.com
+void connect api.example.com
 void project team pending
 void project team accept <invitation-id>
 # or

package/docs/guide/quickstart.md

@@ -36,6 +36,8 @@ bunx void init
 
 Choose your UI framework, a starter, and a deployment target. Vite+ is the default build tool. D1 is a good first database: it runs locally without a separate database server. Choose Cloudflare to deploy to your own account, or skip deployment setup for now.
 
+You do not need to install Vite+ globally. Setup preserves your existing package-manager versions and lockfiles.
+
 With pnpm, `pnpm create void my-app` also creates the project directory and configures native build permissions for you.
 
 ## Run locally

package/docs/guide/sandboxes.md

@@ -56,6 +56,8 @@ File operations live under `sandbox.files`: `readFile`, `writeFile`, `stat`, `ls
 
 To reach a server inside the container, await `sandbox.fetch(port, new Request(url))`. `sandbox.running()` checks whether the container is running; `sandbox.destroy()` stops it.
 
+On native Cloudflare deployments, `sandbox.fetch()` also supports WebSocket upgrade requests. Return its response from your Worker handler to connect the client to the container. WebSocket upgrades are currently unavailable on managed Void deployments.
+
 `getSandbox()` options include `inactivityTimeoutMs` (default ten minutes, maximum six hours), `enableInternet` (default `false`), and string `labels`. Internet access and labels take effect on the next container start. `binding` selects a custom native binding; managed platforms use the configured binding.
 
 For code that runs on both deployment targets, use `getSandbox()`. Direct access through `c.env.SANDBOX` is available only on local and native Cloudflare deployments.

package/docs/reference/api/deploy.md

@@ -0,0 +1,23 @@
+# Deployment artifacts
+
+Use `void/deploy` from Node.js to prepare a built Void app for a managed platform deployment without platform credentials.
+
+Build the app in managed mode inside its isolated environment:
+
+```sh
+VOID_DEPLOY_BUILD=1 VOID_DEPLOY_PROJECT_ID=artifact npm run build
+```
+
+These values select a platform-compatible build. `artifact` is a build marker, not an existing project ID or a credential; the target project is selected during publish approval.
+
+```ts
+import { prepareDeployArtifact } from 'void/deploy';
+
+const { artifact, assets } = await prepareDeployArtifact('/path/to/app');
+```
+
+`artifact` contains the deployment manifest, content-addressed asset metadata, and base64 Worker modules. `assets` maps asset URL paths to base64 bytes. Keep this result immutable while requesting [publish approval](/guide/platform/administration/connected-apps).
+
+Preparation packages existing build output; it does not build, contact a platform, provision resources, or deploy. It supports Void Cloudflare Worker builds. Node targets, static output, remote data, deploy-time prerendering, Sandbox, and Live resources require the normal `void deploy` workflow instead.
+
+Run preparation inside the same isolated environment as the app build. App configuration and build plugins execute project code; keep platform credentials on the publishing server.

package/docs/reference/api/pages.md

@@ -218,6 +218,8 @@ Imported from `"@void/solid"`.
 
 Solid `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
+Solid re-creates the page on GET navigation and whenever the route or its params change, so `useForm()` picks up the destination record's URL and defaults; layouts persist. Within the same record, back/forward, mutations, and `router.refresh()` keep the page and update its props in place, as do resolved deferred props, so read props inside JSX or memos instead of copying them in the component body. Set `preserveState` explicitly to override the default for navigation within the same record.
+
 ## Markdown Package {#markdown-package}
 
 The optional `@void/md` package adds Markdown pages to Pages Routing. Install it alongside a Pages adapter and add `voidMarkdown()` to your Vite plugins.

package/docs/reference/api.md

@@ -25,6 +25,7 @@ Use this reference to find public imports, signatures, and return types. For set
 | [Durable State and WebSockets](./api/durable.md)   | Persistent objects and typed connections.                       |
 | [Database and seeding](./api/database.md)          | Queries, operators, and seed scripts.                           |
 | [KV, storage, AI, and logging](./api/resources.md) | Resource clients, cache revalidation, and logs.                 |
+| [Deployment artifacts](./api/deploy.md)            | Package built apps for managed deployment.                      |
 | [Types](./api/types.md)                            | Handler context, route types, and head metadata.                |
 | [Environment variables](./api/env.md)              | Validated environment values and binding types.                 |
 | [Pages adapters](./api/pages.md)                   | React, Vue, Svelte, Solid, and Markdown.                        |
@@ -41,7 +42,7 @@ Import Void's app-facing APIs from these paths:
 | `void/client`             | `fetch`, `fetchStream`, `FetchError`, `auth`, `createAuthClient`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                       |
 | `void/client/{framework}` | Same as `void/client`, with framework-specific Better Auth clients for `react`, `vue`, `svelte`, and `solid`                                                                                                                                                                                                                                                                                                                                                                   |
 | `void/ws`                 | `defineRoom`, `defineWebSocket`, `connect`, WebSocket context and connection types                                                                                                                                                                                                                                                                                                                                                                                             |
-| `void/durable`            | `defineDurableState`, typed state/RPC/context/migration types                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `void/durable`            | `defineDurableState`, `defineDurableObject`, typed state/RPC/context/migration types                                                                                                                                                                                                                                                                                                                                                                                           |
 | `void/sse`                | `eventStream`, `formatSse`, `formatSseText`, `getLastEventId`, `SseStreamClosedError`, SSE message and stream types                                                                                                                                                                                                                                                                                                                                                            |
 | `void/sse/client`         | `connectEventStream`, browser `EventSource` wrapper types                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `void/live`               | `defineLiveStream`, SSE topic fanout runtime types. Server-only.                                                                                                                                                                                                                                                                                                                                                                                                               |

package/docs/reference/cli/auth.md

@@ -13,7 +13,7 @@ void connect --platform void
 
 Connect a project to its deployment destination. With no arguments, choose Cloudflare or a Void platform interactively. A URL selects a Void platform directly. `--platform void` offers saved platforms and an option to enter another URL.
 
-You can omit `https://` from a platform URL: `void connect platform.example.com` connects to `https://platform.example.com`. This also works in the interactive prompt. For a local HTTP platform, include the scheme, such as `http://localhost:8787`.
+You can use a hostname: `void connect platform.example.com` connects over HTTPS. Loopback hosts (`localhost`, `127.0.0.1`, and `[::1]`) default to HTTP, so use `void connect localhost:8787` for a local platform. This also works in the interactive prompt. Include a scheme to override the default, for example `void connect https://localhost:8787`.
 
 For Cloudflare, Void signs in through the browser when needed, selects an accessible account, and saves `cloudflare.account_id` in `void.config.ts` or resolved state in `void.lock.json`. It shares this setup with `void init`. An existing account selection is preserved; conflicting or inaccessible account settings must be resolved before continuing.
 

package/docs/reference/cli/database.md

@@ -24,15 +24,21 @@ Show migration status. Displays which migrations are applied or pending locally,
 
 ## `void db reset` {#void-db-reset}
 
-Drop the development database and re-apply all migrations. D1 resets the local database; PostgreSQL and MySQL drop all tables in the `DATABASE_URL` database from `.env`. Does not affect the deployed database.
+```
+void db reset [--yes]
+```
+
+Drop the development database and re-apply all migrations. D1 resets the local database; PostgreSQL and MySQL drop all tables in the `DATABASE_URL` database from `.env`.
+
+When that `DATABASE_URL` points to a host other than `localhost`, Void names the database and asks before dropping its tables. Pass `--yes` to skip the prompt in scripts and CI; without a terminal, the command stops unless `--yes` is set. If `.env` uses the same URL as your deployment (for example after `void db connect`), reset drops the deployed tables.
 
 ## `void db seed` {#void-db-seed}
 
 ```
-void db seed [--file <path>]
+void db seed [--file <path>] [--yes]
 ```
 
-Reset the local database, re-apply all migrations, then execute a seed file.
+Reset the local database, re-apply all migrations, then execute a seed file. The reset works like `void db reset`, including the prompt and `--yes`.
 
 If `--file` is omitted, Void looks for default seed files in this order: `db/seed.ts`, `db/seed.mts`, `db/seed.js`, `db/seed.mjs`, `db/seed.sql`.
 

package/docs/reference/cli/deploy.md

@@ -62,7 +62,7 @@ If no project is linked and no override is provided, CLI prompts to link or crea
 To deploy to another connected Void platform for one invocation:
 
 ```sh
-void connect https://second.example.com
+void connect second.example.com
 VOID_API_URL=https://second.example.com void deploy --platform void --project my-app
 ```
 

package/docs/reference/cli/platform-installation.md

@@ -40,7 +40,7 @@ The installed platform needs a separate runtime token to provision resources for
 
 To enable email during install or upgrade, set both `VOID_EMAIL_SENDER_DOMAIN` and `VOID_EMAIL_SHARED_ZONE_ID`. Void records the pair for later upgrades; supplying only one is an error.
 
-Use `--dashboard-url https://dash.example.com` when deploying the optional user
+Use `--dashboard-url `[`https://dash.example.com`](https://dash.example.com) when deploying the optional user
 dashboard separately. The URL must be an HTTPS origin without credentials, a
 path, query, or fragment. Void permits that origin's login callbacks and saves
 it for later maintenance; it does not deploy a dashboard Worker. Omission keeps

package/docs/reference/cli/setup.md

@@ -33,6 +33,8 @@ void init [--tsconfig] [--github] [--git | --no-git]
 
 Set up a new or existing Void project. In an empty directory, choose Vite+ or Vite, a framework, and a D1, PostgreSQL, MySQL, or Static Pages starter.
 
+Vite+ projects install dependencies through `vp install`; no global Vite+ installation is required. Void preserves existing package-manager versions and lockfiles. New Vite+ projects without a package-manager configuration use pnpm without pinning a version.
+
 In an existing app, Void adds missing dependencies and scripts and updates the Vite config. If it cannot edit your config, it prints the snippet to add.
 
 The wizard also sets up TypeScript, agent instructions, environment declarations, and a deployment target. Choose Cloudflare, a Void platform, or skip deployment setup. If you skip sign-in, run `void connect` when you're ready. See [Quick Start](../../guide/quickstart.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.26.1",
+  "version": "0.28.0",
   "description": "Full-stack framework and deployment CLI for Cloudflare Workers, powered by Vite.",
   "homepage": "https://void.cloud",
   "bugs": {
@@ -26,23 +26,15 @@
   ],
   "type": "module",
   "imports": {
-    "#self": "./dist/index.mjs",
     "#self/_env": "./dist/runtime/env.mjs",
     "#self/email": "./dist/runtime/email.mjs",
     "#self/env": "./dist/runtime/env-public.mjs",
     "#self/client": "./dist/runtime/client.mjs",
     "#self/handler": "./dist/runtime/handler.mjs",
-    "#self/pages-head": "./dist/pages/head.mjs",
-    "#self/pages-protocol": "./dist/pages/protocol.mjs",
     "#self/queues": "./dist/runtime/queues.mjs",
     "#self/remote": "./dist/runtime/remote/index.mjs",
     "#self/remote/binding-handler": "./dist/runtime/remote/binding-handler.mjs",
-    "#self/response": "./dist/runtime/response.mjs",
     "#self/sandbox": "./dist/runtime/sandbox.mjs",
-    "#self/sse": "./dist/runtime/sse.mjs",
-    "#self/sse/client": "./dist/runtime/sse-client.mjs",
-    "#self/live": "./dist/runtime/live.mjs",
-    "#self/live/client": "./dist/runtime/live-client.mjs",
     "#self/runtime/live-server": "./dist/runtime/live-server.mjs",
     "#self/runtime/fetch": "./dist/runtime/fetch.mjs",
     "#self/runtime/fetch-stream": "./dist/runtime/fetch-stream.mjs",
@@ -335,6 +327,10 @@
       "types": "./dist/runtime/limits.d.mts",
       "import": "./dist/runtime/limits.mjs",
       "require": "./dist/runtime/limits.mjs"
+    },
+    "./deploy": {
+      "types": "./dist/deploy.d.mts",
+      "import": "./dist/deploy.mjs"
     }
   },
   "dependencies": {
@@ -346,15 +342,15 @@
     "@cloudflare/workers-auth": "^0.13.1",
     "@cloudflare/workers-types": "^5.20261009.1",
     "@napi-rs/keyring": "^2.1.0",
-    "@void/deploy-cloudflare": "0.26.1",
-    "@void/deploy-core": "0.26.1",
-    "@void/edge": "0.26.1",
-    "@void/isr": "0.26.1",
-    "@void/platform": "0.26.1",
+    "@void/deploy-cloudflare": "0.28.0",
+    "@void/deploy-core": "0.28.0",
+    "@void/edge": "0.28.0",
+    "@void/isr": "0.28.0",
+    "@void/platform": "0.28.0",
     "better-auth": "^1.7.7",
     "better-sqlite3": "^13.0.3",
     "blake3-jit": "^1.1.0",
-    "cf": "^1.0.0-beta.13",
+    "cf": "^1.0.0-beta.14",
     "drizzle-arktype": "^0.1.3",
     "drizzle-kit": "^0.31.11",
     "drizzle-orm": "^0.45.3",
@@ -371,7 +367,8 @@
     "mysql2": "^3.24.5",
     "pg": "^8.23.1",
     "postal-mime": "^4.0.5",
-    "proper-lockfile": "^4.1.2"
+    "proper-lockfile": "^4.1.2",
+    "terminal-link": "^5.0.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.5.8",
@@ -397,7 +394,7 @@
     "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "@void/md": "0.26.1",
+    "@void/md": "0.28.0",
     "arktype": ">=2.0.0",
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",

package/skills/void/SKILL.md

@@ -22,8 +22,9 @@ Use `void` and `@void/*` in imports, examples, and package manifests. Follow the
 project's existing framework and deployment destination. Deploying to a Void
 platform requires an explicit `void connect <url>` first; never infer a platform
 from old examples, tokens, or project IDs.
-Platform hostnames passed to `void connect` default to HTTPS; include `http://`
-explicitly when connecting to a local HTTP platform.
+Platform hostnames passed to `void connect` default to HTTPS. Loopback hosts
+(`localhost`, `127.0.0.1`, and `[::1]`) default to HTTP: `void connect localhost:8787`.
+An explicit scheme overrides the default.
 For a one-time deployment elsewhere, connect to that platform, then set
 `VOID_API_URL` for the deploy command and pass `--project <slug>`. This preserves
 the app's existing saved destination, including when the target project is new.
@@ -50,6 +51,7 @@ the app's existing saved destination, including when the target project is new.
 | SSR and caching                            | `docs/guide/ssr.md`, `docs/guide/edge/*.md`                                               |
 | Rewrites, redirects, fallbacks             | `docs/guide/edge/rewrites.md`, `docs/guide/edge/redirects.md`, `docs/reference/config.md` |
 | Static site generation                     | `docs/guide/ssg.md`                                                                       |
+| Connected apps and artifact preparation    | `docs/guide/platform/administration/connected-apps.md`, `docs/reference/api/deploy.md`    |
 | Deployment and CI                          | `docs/guide/deployment.md`, `docs/reference/cli/deploy.md`                                |
 | Install or maintain a company platform     | `docs/guide/self-hosted-platform.md`, `docs/reference/cli/platform-installation.md`       |
 | Develop or deploy a platform fork          | `docs/guide/platform-development.md`, `docs/guide/self-hosted-platform.md`                |

package/dist/auth-BgX2qYSY.mjs

@@ -1,2 +0,0 @@
-import { a as getApiUrl, m as runPlatformLogin, s as getSiteDomain } from "./auth-B5_tZLxT.mjs";
-export { getApiUrl, getSiteDomain, runPlatformLogin };

package/dist/cf-build-output-H9a97vME.mjs

@@ -1,2 +0,0 @@
-import { t as prepareCfBuildOutput } from "./cf-build-output-DjvB_872.mjs";
-export { prepareCfBuildOutput };

package/dist/client-By4JjMw_.mjs

@@ -1,2 +0,0 @@
-import { r as PlatformClient } from "./client-C2Prx_Bi.mjs";
-export { PlatformClient };

package/dist/collect-DLyFDiKW.mjs

@@ -1,2 +0,0 @@
-import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
-export { collectMigrations };

package/dist/config-5r-YpMC-.mjs

@@ -1,2 +0,0 @@
-import { m as readConfig, u as getDatabaseDialect } from "./config-DiowPT80.mjs";
-export { getDatabaseDialect, readConfig };