@jimhoyd/urlcode 0.3.0 → 0.4.0-alpha.2

package/README.md

@@ -1,37 +1,115 @@
 # URLCode
 
-**A portable runtime for programmable URL behavior.** Define an application's
-public URL surface in YAML, add isolated JavaScript only where declarative
-handlers are not enough, and run the same project locally or on your own
-infrastructure. Your routes, source and data remain yours.
+**A portable runtime for programmable URL behavior, and the framework that grows
+from it.** Declare an application's public URL surface in YAML, add JavaScript
+only where declarative handlers are not enough, and run the same
+project locally, in a container, on your own infrastructure or on a provider
+adapter. When the project gets serious, add accounts and an administration
+console as operator-installed extensions instead of building them again.
+**URL behavior as code.**
 
 [![Verify](https://github.com/jimhoyd-com/urlcode/actions/workflows/ci.yml/badge.svg)](https://github.com/jimhoyd-com/urlcode/actions/workflows/ci.yml)
 
-[Documentation](docs/README.md) · [Starter](https://github.com/jimhoyd-com/urlcode-template) · [Contributing](CONTRIBUTING.md) · [Security](SECURITY.md)
+[Documentation](docs/README.md) · [The framework](docs/FRAMEWORK.md) · [For AI agents](llms.txt) · [Starter](https://github.com/jimhoyd-com/urlcode-template) · [Contributing](CONTRIBUTING.md) · [Security](SECURITY.md)
+
+**Your AI should build your application, not your framework.** Coding agents
+rebuild the same routing, validation, middleware, policies and authentication
+plumbing on every project, and the person ends up owning the plumbing. URLCode
+represents those behaviors as a strict, portable YAML contract that both people
+and agents can read: the agent describes what, the runtime owns how, and
+generated code goes to the part that is actually the application. It is
+infrastructure for AI-built software, not a framework for building AI models.
+[Why](docs/PROJECT-DIRECTION.md#why-your-ai-should-build-your-application-not-your-framework) ·
+[next steps](docs/NEXT-STEPS.md).
+
+## What it is
+
+A project is a `urlcode.yaml` with `version: "1"`. Each route has exactly one
+handler: `redirect`, `respond`, `page`, `static`, `download`, `function`,
+`proxy`, `conditional` or an `extension` mount, with optional ordered
+`middleware`. The runtime validates the whole project before serving it,
+compiles it once, and refuses anything a target cannot enforce with the route
+named. Functions and middleware run trusted, in-process, with full Node
+access by default; a route opts into an isolated QuickJS/WebAssembly sandbox
+with a fresh heap per call and no Node, filesystem or network by declaring
+`sandbox: true`. Either way, secrets reach them only through operator grants
+pinned to the project revision.
+
+URLCode is not a URL shortener: stored short links are an operator-installed
+extension, not core's job. It is not a
+general Node web framework: routing, validation, middleware wiring and
+policies are declared in YAML, not hand-wired; isolating a specific route's
+code from the host is an explicit `sandbox: true` opt-in, not something every
+route gets by writing a handler. It is not a provider configuration format:
+infrastructure settings stay out of route YAML.
+See [project direction](docs/PROJECT-DIRECTION.md).
+
+## The framework
+
+Four packages, one project shape. A project climbs from redirects to a full
+application by adding YAML; the operator wires trusted packages in one host
+file outside the project. The full map, the composition contract and the rules
+an AI agent must follow are in [the framework](docs/FRAMEWORK.md).
+
+| Package | Adds | Status |
+|---|---|---|
+| [urlcode](https://github.com/jimhoyd-com/urlcode) (this repository) | Runtime, CLI, policies, provider adapters, extension contract | `0.4.0-alpha.2` (alpha) on top of the `0.3.0` release, Apache-2.0 |
+| [urlcode-ui](https://github.com/jimhoyd-com/urlcode-ui) | Shared presentation: escaped templates, shadcn/ui partials, themes, translations | `0.1.0-alpha.5` on npm, alpha: review pending |
+| [urlcode-auth](https://github.com/jimhoyd-com/urlcode-auth) | Accounts: password, passkeys, OIDC, email codes, TOTP, sessions, roles, account page | `0.1.0-alpha.3` on npm, alpha: review pending |
+| [urlcode-admin](https://github.com/jimhoyd-com/urlcode-admin) | Administration: users, sessions, roles, audit, approvals, cases, impersonation | `0.1.0-alpha.3` on npm, alpha: review pending |
+| [urlcode-dynamic-link](https://github.com/jimhoyd-com/urlcode-dynamic-link) | Stored short links: the mount-based successor to core's removed `link` handler | `0.1.0-alpha.2` on npm, alpha: review pending |
+| [urlcode-middleware](https://github.com/jimhoyd-com/urlcode-middleware) | Per-route middleware through the extension seam, alongside core's native array | `0.1.0-alpha.2` on npm, alpha: review pending |
+| [urlcode-short](https://github.com/jimhoyd-com/urlcode-short) | A complete link shortener assembled from the packages above | `0.1.0-alpha.2` on npm, alpha: review pending |
+
+Every version in this table is the one published to npm under the `alpha`
+dist-tag, and they are released together in the order core → ui → auth →
+admin → dynamic-link/middleware → short. The authoritative cross-repository
+register, including each package's declared peer ranges and the rules that
+keep them consistent, is
+[docs/VERSION-ALIGNMENT.md](docs/VERSION-ALIGNMENT.md).
 
-URLCode is not a URL shortener. Short links are one supported route type beside
-redirects, validated HTTP responses, isolated request functions, middleware,
-pages, static assets and downloads. It is also not a general Node web framework:
-the project format intentionally describes bounded behavior that a runtime can
-validate, inspect and eventually carry across hosting providers.
+```yaml
+version: "1"
+extensions:
+  auth:  { version: "1", config: { registration: "off" } }
+  admin: { version: "1", config: {} }
+routes:
+  /go:          { redirect: { url: https://example.com, status: 302 } }
+  /account/*:   { extension: auth,  methods: [GET, HEAD, POST] }
+  /admin/*:     { extension: admin, methods: [GET, HEAD, POST] }
+  /private:
+    respond: { text: Signed in }
+    policies: { extensions: { auth: {} } }
+```
 
-See [project direction](docs/PROJECT-DIRECTION.md) for the product boundary,
-the relationship to application projects and the license.
+The YAML names logical extensions; it never names packages, code, databases
+or credentials. `urlcode-auth init` writes the operator host, keys and a
+private data directory beside the project; `urlcode serve --host-file` loads
+it. Cross-repository acceptance is tracked in
+[issue 58](https://github.com/jimhoyd-com/urlcode/issues/58).
 
 ## Status
 
-`0.2.0` is the current local/self-hosted release of the implemented
-contract, following `0.1.0`, the first stable one. It includes redirects, parameters, JavaScript
-functions, middleware, live short-link storage, pages, static assets, downloads, starters, tests and process/container packaging. See the
-[implemented contract](docs/SPECIFICATION.md), [operations guide](docs/OPERATIONS.md)
-and [roadmap](ROADMAP.md) for limits and unfinished work.
-
-Live-link storage uses separate bounded reader/writer pools. It requires a Node
-build containing a patched SQLite version — 3.51.3 or newer, 3.50.7, or 3.44.6 —
-which some current releases on a supported Node line do not carry. Run
-`urlcode doctor` and check `liveLinks` before relying on it; everything else
-runs on any supported Node.
-See [pool controls and scaling limits](docs/DYNAMIC-LINKS.md#separate-reader-and-writer-pools).
+`0.4.0-alpha.2` is the current release of the extension contract and the
+agent tooling, on top of the `0.3.0` self-hosted release. `0.4.0-alpha.1`
+added the extension contract, capabilities and provider conformance, strict
+redirect interchange, bulk import, recipes and search, TypeScript guest
+authoring, conditions, bounded proxy and signals, and the MCP read and
+authoring modes. `0.4.0-alpha.2` then made `function` and `middleware` routes
+run trusted and unsandboxed by default, with `sandbox: true` as a per-route
+opt-in, and removed the native `link:`/`dynamicLinks:` YAML shape. That is a
+behaviour change for existing projects with no YAML edit; read
+[the roadmap entry](ROADMAP.md) before upgrading. Use the schema and docs from
+the runtime revision you run.
+The [roadmap](ROADMAP.md) separates implemented from planned, and
+[release readiness](docs/RELEASE-READINESS.md) records what is proven and
+what is not: provider deployments, soak and independent security review
+remain open.
+
+Stored short links have moved out of core into
+[urlcode-dynamic-link](https://github.com/jimhoyd-com/urlcode-dynamic-link)
+(mount-based, like `auth`/`admin`, published on npm); core no longer has a
+native `link` handler.
 
 URLCode is free and open-source software licensed under the
 [Apache License 2.0](LICENSE). Commercial use, modification, redistribution and
@@ -42,7 +120,9 @@ self-hosting are permitted under its terms.
 Start with the [YAML guide and recipe book](docs/YAML-GUIDE.md),
 [complete field reference](docs/YAML-REFERENCE.md), and
 [runnable 25-route cookbook](examples/cookbook/README.md). For AI-assisted
-authoring, use [the AI guide](docs/AI-AUTHORING.md) and [llms.txt](llms.txt).
+authoring, use [the AI guide](docs/AI-AUTHORING.md), the bundled agent skills
+([authoring](.claude/skills/urlcode-authoring/SKILL.md),
+[operations](.claude/skills/urlcode-operations/SKILL.md)) and [llms.txt](llms.txt).
 Follow [organization and readability practices](docs/BEST-PRACTICES.md) as your
 project grows. Operators should read [capacity/concurrency](docs/CAPACITY.md) and the
 [DDoS and recovery playbook](docs/RESILIENCE.md). Embedding the runtime from
@@ -62,281 +142,141 @@ npm ci
 npm run dev
 ```
 
-Live stored-link routes require **`dynamicLinks: true`** in the entry `urlcode.yaml`;
-the starter explicitly sets false. Ordinary functions and parameterized redirects
-do not need it. [Live-link setup](docs/DYNAMIC-LINKS.md).
-
 ## Built with URLCode
 
-[urlcode-shortener](https://github.com/jimhoyd-com/urlcode-shortener) is a
-standalone, account-free demo built on URLCode's public runtime and storage APIs.
+[urlcode-short](https://github.com/jimhoyd-com/urlcode-short) is a
+standalone, account-free demo built on URLCode's public runtime. It predates
+this repository's removal of the native link-store API from core; its
+retrospective should be read alongside that change, not as current guidance.
 It combines short links that expire after one hour or less, QR downloads, and a
-shadcn/ui + Tailwind frontend. URLCode handles the page/assets and stored-link
-redirects; the application adds anonymous creation and its own limits.
+shadcn/ui + Tailwind frontend. URLCode handles the page/assets and routing; the
+application adds anonymous creation, stored-link storage and its own limits.
 
-Read its [build retrospective](https://github.com/jimhoyd-com/urlcode-shortener/blob/main/docs/BUILD-RETROSPECTIVE.md)
+Read its [build retrospective](https://github.com/jimhoyd-com/urlcode-short/blob/main/docs/BUILD-RETROSPECTIVE.md)
 for what the runtime supplied, what the application still needed, and proposed
 improvements. The demo's license, hosting and production validation remain open;
 it does not change URLCode's Apache-2.0 license or guest isolation model.
 
-[urlcode-docs](https://github.com/jimhoyd-com/urlcode-docs) demonstrates URLCode
-hosting a static documentation site with shadcn/ui and Tailwind. It syncs this
-repository’s Markdown and examples at a pinned revision, applies templates through
-sandboxed middleware during the build, and serves the output through native
-page/static/download routes. This repository remains the documentation source of
-truth. See the [docs-site retrospective](https://github.com/jimhoyd-com/urlcode-docs/blob/main/docs/BUILD-RETROSPECTIVE.md)
-for reuse, integration work and upstream improvements. Hosting and a public domain
-are not yet selected; the original site-code license is pending.
+`urlcode-docs` demonstrates URLCode hosting a static documentation site with
+shadcn/ui and Tailwind: content authored directly in that repository, applying
+templates through its own sandbox-opted-in (`sandbox: true`) middleware during
+the build, served through native page/static/download routes. That repository
+is currently private, so it isn't publicly browsable yet. Hosting and a public
+domain are not yet selected; the original site-code license is pending.
 
 ## Start from YAML
 
 Already wrote `urlcode.yaml`? Run `urlcode scaffold --project ./my-links --dry-run`,
 then remove `--dry-run` to create missing modules, pages and directories. Existing
 files are preserved; code placeholders return 501 until implemented.
-[Scaffolding guide](docs/SCAFFOLDING.md).
+[Scaffolding guide](docs/SCAFFOLDING.md). Node 22.13+ installed, 22.18+ to run
+the TypeScript source; the separate `urlcode-auth` extension may have its own
+SQLite build requirement, unverified from this repository.
 
 ## Try it
 
-Requires Node.js 22.13+ and npm; CI targets Node 22, 24 and 26 on macOS, Linux and
-Windows.
-
 ```sh
-npm install --global urlcode        # or: brew tap jimhoyd-com/urlcode && brew install urlcode
+npm install --global @jimhoyd/urlcode     # or: brew tap jimhoyd-com/urlcode && brew install urlcode
 urlcode init my-urls && cd my-urls
 urlcode dev
 ```
 
-See [installation](docs/INSTALL.md) for the install script, the container image
-and verifying a release's signed provenance. To work from a clone instead:
-
-```sh
-git clone https://github.com/jimhoyd-com/urlcode.git
-cd urlcode
-make dev
-```
-
-`make dev` installs dependencies if needed and starts the included function/redirect demo.
-No global install, account, database, Docker or configuration step is required.
-A clone runs the TypeScript source directly (`node src/cli.ts`, which needs
-Node 22.18+); the installed package runs the built `dist/cli.js`.
-Without Make (including Windows), use:
-
-```sh
-npm ci
-npm run dev
-```
-
-Open `http://127.0.0.1:3000/hello/Ada` to run your custom function,
-`/go` for a regular redirect.
-Edit `starters/default/routes/` or `functions/hello.mjs` under
-that starter; valid changes reload automatically. Press Ctrl+C to stop.
-In another terminal, run `make test-project` or `npm run test:project`.
-
-To create your own independent project:
-
-```sh
-make init DEST=../my-links
-make dev PROJECT=../my-links PORT=3001
-# Without Make:
-npm run init -- ../my-links
-npm run dev -- --project ../my-links --port 3001
-```
-
-Choose either command pair; initialization refuses to overwrite existing work.
-[Starters](docs/STARTERS.md) are ordinary application files, independent of the
-runtime checkout. Own them in your own Git repository. Global `npm link` remains
-optional if you want the `urlcode` command everywhere. See
-[local development](docs/LOCAL-DEVELOPMENT.md) for commands and troubleshooting.
+Open `http://127.0.0.1:3000/hello/Ada` for the function route and `/go` for
+the redirect. Edit the YAML; valid changes reload. `urlcode test` runs the
+project's HTTP fixtures. The [install guide](docs/INSTALL.md) covers the
+checksum-verified script, project-local installs, the container image and
+signed provenance. To work from a clone: `git clone … && make dev`.
 
 ## A URL that runs your function
 
-A request to `/hello/Ada` runs your JavaScript and returns
-`{"message":"Hello, Ada!"}`. Put this in `urlcode.yaml`:
-
 ```yaml
 version: "1"
 routes:
   /hello/{name}:
     parameters:
-      - name: name
-        in: path
-        required: true
-        schema: {type: string, minLength: 1, maxLength: 80}
+      - { name: name, in: path, required: true, schema: { type: string, minLength: 1, maxLength: 80 } }
     function:
       source: functions/hello.mjs
-      args:
-        name: {from: path, name: name}
+      args: { name: { from: path, name: name } }
     env:
-      GREETING: {value: Hello}
+      GREETING: { value: Hello }
 ```
 
-And in `functions/hello.mjs`:
-
 ```js
 export default function hello(request, { args, env }) {
   return Response.json({ message: `${env.GREETING}, ${args.name}!` });
 }
 ```
 
-Your function chooses the response: JSON, text, HTML, or a redirect via
-`Response.redirect("https://example.com", 302)`. The starter includes
-this runnable example. Functions run in an isolated sandbox; see its supported
-[API and security boundaries](docs/FUNCTION-SECURITY.md).
+Add `middleware: [{ source: middleware/headers.mjs }]` to wrap any handler with
+`await next()`. Fourteen ready-made middleware patterns ship in the cookbook
+and as `urlcode recipes add middleware`. See [functions and the sandbox](docs/FUNCTION-SECURITY.md)
+and [middleware](docs/MIDDLEWARE.md).
+
+## Everything else in YAML
+
+- **Pages, files, downloads:** `page`, `static`, `download` with MIME detection,
+  ETags, ranges and safety limits. [Assets](docs/ASSETS.md).
+- **HTTP:** methods, validated path/query/header inputs, body limits, response
+  headers and cookies. [HTTP](docs/HTTP.md).
+- **Policies and site conventions:** throttle, agents, security headers,
+  compression, cache; robots, sitemap, favicon, security.txt, llms.txt.
+  [Policies](docs/POLICIES.md), [site](docs/SITE.md).
+- **Conditions, proxy, signals:** exact predicates with disjoint cases; a bounded
+  HTTPS proxy and best-effort webhooks behind operator grants.
+  [Conditions](docs/CONDITIONS.md), [egress](docs/EGRESS.md).
+- **Organization:** `includes` across folders; strict CSV/JSON/YAML and
+  provider-file import; searchable recipes and examples. [Organization](docs/ORGANIZATION.md),
+  [interchange](docs/INTERCHANGE.md), [bulk](docs/BULK.md), [recipes](docs/RECIPES.md).
+- **Checks:** `validate`, `test`, `routes`, `audit --expect-routes`, `benchmark`,
+  `capabilities`, deployment verification and a GitHub Action.
+  [Readiness](docs/READINESS.md), [CI](docs/CI.md).
+
+## Deploy
+
+Self-hosted Node process or container first. `@jimhoyd/urlcode/vercel` and
+`@jimhoyd/urlcode/aws` serve declarative projects as native handlers;
+`urlcode build --target cloudflare` compiles redirects and declared responses
+into a Worker; `urlcode build --target static` compiles redirects and static
+files into plain objects and redirect metadata for S3 + CloudFront, with no
+server at all. Each target refuses at activation or build time what it cannot
+run, with the route named. None has been exercised on its provider yet; the
+adapters have local conformance tests only. [Operations](docs/OPERATIONS.md),
+[capabilities](docs/CAPABILITIES.md), [Vercel](docs/VERCEL.md), [AWS](docs/AWS.md),
+[Cloudflare](docs/CLOUDFLARE.md), [static hosting](docs/STATIC.md).
+
+## For AI agents
+
+[llms.txt](llms.txt) is the compact index; [the framework](docs/FRAMEWORK.md)
+is the map; [AI authoring](docs/AI-AUTHORING.md) is the contract with the
+capability matrix and a copyable task prompt. `urlcode mcp` exposes read-only
+inspection, validation and conversion previews over stdio, and
+`--allow-authoring` adds project-confined authoring tools
+([tooling](docs/TOOLING.md)).
 
-## Reusable middleware
-
-Add an ordered `middleware` list alongside any route handler:
-
-```yaml
-    middleware:
-      - source: middleware/headers.mjs
-```
-
-```js
-export default async function headers(request, context, next) {
-  const response = await next();
-  response.headers.set('x-example-middleware', 'active');
-  return response;
-}
-```
-
-Middleware can return a response early, share request-local `context.state`, or
-wrap the handler with `await next()`. It runs in the same isolated sandbox and
-under one deadline for the whole chain. The starter's function route includes
-this example. See [middleware semantics and limits](docs/MIDDLEWARE.md).
-
-## A URL that redirects
-
-```yaml
-version: "1"
-routes:
-  /go:
-    redirect:
-      url: https://example.com
-      status: 302
-```
-
-Ordinary redirects use an indexed lookup: no database, Lambda or per-route
-user function. Configuration is compiled at startup, not parsed per request.
-Literal paths win over parameterized routes; conflicting definitions fail validation.
-
-Custom functions are ES modules using a documented text/JSON `Request`/`Response`
-subset and validated context. See the
-[starter](starters/default/urlcode.yaml) and [function](starters/default/functions/hello.mjs).
-Functions are treated as untrusted and run inside a QuickJS/WebAssembly sandbox,
-with a fresh heap per invocation. No Node APIs, filesystem, shell, network or
-ambient environment is exposed. Independent worker deadlines bound execution.
-External env/secret bindings require route-scoped operator grants pinned to the
-project revision. See the [security model](docs/FUNCTION-SECURITY.md).
-
-## Pages, files and downloads
-
-Add these routes alongside your functions and redirects:
-
-```yaml
-  /about:
-    page:
-      file: public/about.html
-  /assets/*:
-    static:
-      directory: public/assets
-  /download:
-    download:
-      file: public/guide.txt
-      filename: urlcode-guide.txt
-```
-
-Create the referenced files first. MIME types are detected from file extensions;
-unknown types use `application/octet-stream`. Downloads set attachment headers.
-Optional `contentType` overrides detection. HEAD, ETags, conditional requests and
-single byte ranges are supported. Files are served natively without executing a
-function. See [asset configuration and safety limits](docs/ASSETS.md).
-
-## Organize routes across files
+## Documentation
 
-Keep everything in `urlcode.yaml`, or use its `includes` list to load files from
-folders you choose. The [public template](https://github.com/jimhoyd-com/urlcode-template)
-demonstrates a function file and a redirect file in a nested folder. All commands
-see one combined project. See [organization examples](docs/ORGANIZATION.md).
+Full documentation is authored in a separate `urlcode-docs` repository, where
+new guides, references and recipes belong — but that repository is currently
+private, so its content isn't publicly browsable yet. Until it's made public,
+the practical reference is this README and [`docs/`](docs/README.md) in this
+repository.
 
-## Route matching and adding links
+`docs/` in this repository is contributor and maintainer material — local
+development, CI, the release process, reviews and the generated field
+reference. Reader-facing pages still under `docs/` are being migrated.
 
-Routes support exact paths and non-greedy single-segment parameters such as
-`/r/{code}`. Only static-file mounts support a trailing `/*`; regex routing is
-not supported. `dev` swaps validated configuration snapshots when YAML changes;
-`serve` requires restart/redeployment for YAML changes. Stored short links can
-now be created/updated/deleted live without reloads through the optional
-[dynamic-link handler and management API](docs/DYNAMIC-LINKS.md). See [matching, precedence and dynamic-link behavior](docs/ROUTING.md).
+## Built with URLCode
 
-## Create short links without restarting
+[urlcode-short](https://github.com/jimhoyd-com/urlcode-short), an
+account-free short-link demo with a shadcn/ui front end, and `urlcode-docs`, a
+static documentation site rendered through its own sandbox-opted-in middleware
+at build time (currently a private repository). Both are ordinary consumers of
+the public runtime; urlcode-short's retrospective lists what the runtime
+supplied and what it still had to build.
 
-```yaml
-  /r/{code}:
-    parameters:
-      - name: code
-        in: path
-        required: true
-        schema: {type: string, minLength: 1, maxLength: 128}
-    link:
-      collection: links
-      code: {from: path, name: code}
-```
+## License and contributing
 
-Keep this route in YAML; store individual codes outside Git. Bind an optional
-local SQLite store with `--link-store links=/absolute/links.sqlite`, then use
-`urlcode links create` or the separate authenticated management API. Successful
-record changes are visible without rewriting YAML or rebuilding the route table.
-Ordinary YAML routes still need no database. See [setup, API and limitations](docs/DYNAMIC-LINKS.md).
-
-## HTTP in YAML
-
-Configure methods and validated path/query/header inputs, request body size and
-media types, response headers, cookies, and declared text/JSON responses.
-See the [HTTP configuration reference](docs/HTTP.md) for supported fields and
-examples. Runtime framing and asset validators stay protected.
-
-## Check your links before release
-
-`urlcode routes` lists the configured routes. `urlcode audit --expect-routes 2`
-checks the count, generates native response checks and reports missing route/method
-coverage in your request fixtures. `urlcode benchmark --requests 1000 --concurrency 2`
-measures your local project without following external redirects. Each command
-accepts `--project`. See [readiness and release checks](docs/READINESS.md).
-
-## Commands available
-
-| Command | Purpose |
-|---|---|
-| `init <directory>` | Create an independent starter; refuse existing destinations |
-| `add <url> --alias <code>` | Validate and atomically add a redirect; generate a code if omitted |
-| `validate --local` | Validate config, references, bindings and function initialization; read `.env.local` |
-| `dev` | Local server, watched reload and `.env.local` |
-| `serve` | Fixed production process snapshot; environment injection, no dotenv loading |
-| `test` | Local HTTP assertions from `tests/requests.json`; never follow redirects |
-| `permissions` | Inspect requested bindings and project digest without executing code; grants nothing |
-| `doctor` | Report runtime/platform details and implemented provider scope |
-
-Use `--project <directory>` to select an app. Servers accept `--host`, `--port`
-and `--origin` (public URL origin for functions). Bind defaults to `127.0.0.1`.
-
-## Production direction
-
-The free runtime is meant to be useful and production-capable for people who
-operate it themselves. Current hardening includes strict YAML/schema checks,
-request/response limits, worker deadlines, bounded function concurrency, safe
-configuration replacement, graceful shutdown, health/readiness and structured
-logs without request content. It still needs broader deployment/soak validation
-and the remaining release features. Read [operations](docs/OPERATIONS.md) before
-exposing a server. [Benchmark instructions and measurements](docs/PERFORMANCE.md)
-are available; measurements are not capacity guarantees.
-
-Git owns definitions and code. Secrets stay in ignored `.env.local` for development
-or injected environment values for serving, accessible to functions only through
-an explicit operator policy. Vercel, AWS Lambda and Cloudflare Workers each have a
-target guide in [docs](docs/README.md); none has been deployed to its platform
-yet. Provider secret-store integration, CSV tools, templates/signals,
-Homebrew and richer monitoring are future work. Unsupported config fails rather
-than silently losing behavior. There is no required admin UI or database.
-
-See [contributing](CONTRIBUTING.md), [security](SECURITY.md), and the
-[roadmap](ROADMAP.md).
+Apache-2.0. Commercial use, modification, redistribution and self-hosting are
+permitted. See [contributing](CONTRIBUTING.md), [security](SECURITY.md),
+[governance](GOVERNANCE.md) and the [roadmap](ROADMAP.md).