fix(ai): accept larger Anthropic message requests

2026-11-13 20:12:57 -10:00 · 2026-10-30 18:56:52 +01:00
824 changed files with 18303 additions and 94198 deletions
@@ -47,13 +47,3 @@ jobs:
                  PUTER_TEST_AI_MOONSHOT_API_KEY: ${{ secrets.PUTER_TEST_AI_MOONSHOT_API_KEY }}
                  PUTER_TEST_AI_ZAI_API_KEY: ${{ secrets.PUTER_TEST_AI_ZAI_API_KEY }}
                  PUTER_TEST_AI_ELEVENLABS_API_KEY: ${{ secrets.PUTER_TEST_AI_ELEVENLABS_API_KEY }}
-
-            # Realtime conversations through the SDK against live OpenAI. Builds
-            # the SDK bundle these tests load itself, so it runs even when the
-            # step above fails; the tests skip themselves without the key.
-            - name: Run live realtime conversation tests
-              if: ${{ !cancelled() }}
-              run: npm run setupExtensions && (cd src/puter-js && npm run build) && npx vitest run --config src/puter-js/tests/api/vitest.config.ts src/puter-js/tests/api/realtime/convoLive.test.ts
-              env:
-                  CI: 'true'
-                  PUTER_TEST_AI_OPENAI_API_KEY: ${{ secrets.PUTER_TEST_AI_OPENAI_API_KEY }}
@@ -1,48 +0,0 @@
-name: Notify HeyPuter (dev)
-
-on:
-  workflow_dispatch:
-    inputs:
-      puter_ref:
-        description: "puter branch, tag or SHA"
-        type: string
-        default: "main"
-
-permissions:
-  contents: read
-
-jobs:
-  authorize:
-    if: github.repository == 'HeyPuter/puter'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Require maintain or admin
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ACTOR: ${{ github.triggering_actor }}
-        run: |
-          ROLE=$(gh api "repos/$GITHUB_REPOSITORY/collaborators/$ACTOR/permission" --jq .role_name)
-          if [ "$ROLE" != "maintain" ] && [ "$ROLE" != "admin" ]; then
-            echo "::error::$ACTOR has role '$ROLE'; maintain or admin required"
-            exit 1
-          fi
-
-  notify:
-    needs: authorize
-    runs-on: ubuntu-latest
-    # Holds HEYPUTER_DISPATCH_TOKEN; limited to main so branch copies of this file can't read it.
-    environment: heyputer-dispatch
-    steps:
-      - name: Trigger heyputer dev deploy
-        env:
-          PUTER_REF: ${{ inputs.puter_ref }}
-          TOKEN: ${{ secrets.HEYPUTER_DISPATCH_TOKEN }}
-        run: |
-          jq -nc --arg ref "$PUTER_REF" \
-            '{event_type: "puter-dev-requested", client_payload: {puter_ref: $ref}}' |
-          curl -fsS -X POST \
-            -H "Authorization: token $TOKEN" \
-            -H "Accept: application/vnd.github.v3+json" \
-            https://api.github.com/repos/HeyPuter/heyputer/dispatches \
-            -d @-
-          echo "Requested \`$PUTER_REF\`" >> "$GITHUB_STEP_SUMMARY"
@@ -8,7 +8,6 @@ on:
 jobs:
  notify:
    runs-on: ubuntu-latest
-    environment: heyputer-dispatch
    steps:
      - name: Trigger heyputer build
        run: |
@@ -16,4 +15,4 @@ jobs:
            -H "Authorization: token ${{ secrets.HEYPUTER_DISPATCH_TOKEN }}" \
            -H "Accept: application/vnd.github.v3+json" \
            https://api.github.com/repos/HeyPuter/heyputer/dispatches \
-            -d '{"event_type":"puter-main-updated","client_payload":{"puter_ref":"main"}}'
+            -d '{"event_type":"puter-main-updated","client_payload":{"puter_ref":"main"}}'
@@ -118,13 +118,9 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          # The base branch lives in this repo; for a fork PR, the head
-          # repo's copy of it can be arbitrarily stale.
          - ref: ${{ github.base_ref }}
-            repository: ${{ github.repository }}
            artifact: base
          - ref: ${{ github.head_ref }}
-            repository: ${{ github.event.pull_request.head.repo.full_name }}
            artifact: pr

    steps:
@@ -133,7 +129,7 @@ jobs:
        uses: actions/checkout@v7
        with:
          ref: ${{ matrix.ref }}
-          repository: ${{ matrix.repository }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}

      - name: Set up Node.js
        if: needs.changes.outputs.puterjs == 'true'
@@ -176,10 +172,7 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@v7

-      # Missing when the PR leg failed; `coverage (pr)` already reports that.
      - name: Download PR coverage
-        id: pr-coverage
-        continue-on-error: true
        uses: actions/download-artifact@v8
        with:
          name: puterjs-coverage-pr
@@ -189,7 +182,6 @@ jobs:
      # base run) — then report without the comparison column.
      - name: Download base coverage
        id: base-coverage
-        if: steps.pr-coverage.outcome == 'success'
        continue-on-error: true
        uses: actions/download-artifact@v8
        with:
@@ -197,7 +189,7 @@ jobs:
          path: coverage-base

      - name: Report coverage on PR
-        if: steps.pr-coverage.outcome == 'success' && steps.base-coverage.outcome == 'success'
+        if: steps.base-coverage.outcome == 'success'
        uses: davelosert/vitest-coverage-report-action@v2
        with:
          name: puter.js SDK
@@ -206,7 +198,7 @@ jobs:
          json-summary-compare-path: coverage-base/coverage-summary.json

      - name: Report coverage on PR (no base comparison)
-        if: steps.pr-coverage.outcome == 'success' && steps.base-coverage.outcome != 'success'
+        if: steps.base-coverage.outcome != 'success'
        uses: davelosert/vitest-coverage-report-action@v2
        with:
          name: puter.js SDK
@@ -159,42 +159,13 @@ The reference has two kinds of page:

 An overview page answers "what is this API and is it what I need?", and a function page answers "how exactly does this call behave?". A change to one function usually only touches that function's page, so a new `kv.list()` option goes in `KV/list.md` without a matching update to `KV.md`. Don't copy a function's options, limits, or edge cases onto the overview page for completeness. Where a detail goes is a judgment call, not a hard rule: update the overview when a change affects how someone would describe the API as a whole.

-When you add a page, add it to [src/docs/src/sidebar.js](src/docs/src/sidebar.js) under its area, or it won't show up in the navigation.
-
-**Sidebar order.** Order the API areas in the sidebar by how often developers use them, most common first. Overview stays first and Objects stays last. Inside an area, order the pages by use too, and keep pages that make up one feature next to each other, such as `share()`, `unshare()`, `listShared()`, and `listSharedByMe()`. A group goes where its most-used page would go. A helper that only supports another function, such as `listModels()` for `chat()`, goes by its own use. Put create, list, get, update, and delete in that order, and constants such as `MAX_KEY_SIZE` last. The function list on the area's overview page uses the sidebar's order. When you add a runnable example, add its HTML to `src/docs/src/playground/examples/<slug>.html`, register the slug in [src/docs/src/examples.js](src/docs/src/examples.js), and link the code block to it by putting the slug after the language with a semicolon (` ```html;kv-set `).
-
-### Function page layout
-
-A function page opens with one sentence that says what the function does, in its own paragraph, such as "Given a prompt, generate an image using AI." Put any more detail in the paragraphs after it.
-
-After the intro, a function page has these `##` sections, in this order:
-
-1. Syntax
-2. Parameters
-3. Return value
-4. Errors, if the function has any
-5. Sections for specific topics, if the page needs them, with `## Model-specific features` last
-6. Examples
-
-[chat.md](src/docs/src/AI/chat.md) follows this layout.
-
- **Options as a table.** Document an options object as a table with Option, Type, and Description columns. Give each option its own row, even when two options go together, such as `width` and `height`. Order the rows by how often developers use them, most common first, without group rows. In chat.md that's the core options, then reasoning, tools, response handling, request control, and output.
- **Common options in the table, model-specific behavior in its own section.** A page whose function works with many models or providers, such as [chat.md](src/docs/src/AI/chat.md) and [txt2img.md](src/docs/src/AI/txt2img.md), splits its options this way:
-  - **The options table** under Parameters lists the options that work with every model, and describes each one the way it works for every model.
-  - **`## Model-specific features`**, the last section before Examples, covers everything else. It has a `###` for each model family or provider, named after it, such as "OpenAI models" or "Cloudflare models". Under it go the options only some models accept, and the common options a model handles differently, such as a narrower range, other allowed values, or an option it ignores.
-  - **Write there only what's different.** A `###` lists an option only when that model or provider adds it or handles it differently. An option that works the same everywhere stays out, even if the provider supports it, and a model or provider with nothing different gets no `###`.
-  - **Model-specific features is the only place for model-specific details.** Every limit, format, allowed value, default, price, or quirk that applies to some models goes there, in that model's or provider's `###`, and nowhere else. The options table and topic sections (such as Image inputs or Video input) describe what's true for every model and link to Model-specific features for the rest. Don't add a table or sentence there that compares providers or repeats a model's limits. Each copy is another source of truth to keep in sync, and copies drift when a model changes.
-  - **Link the two.** Directly under the options table, put `Some models accept additional options or handle these options differently. See [Model-specific features](#model-specific-features).` A row whose option behaves differently on some models can also end with `See [Model-specific features](#model-specific-features).`
- **A long topic gets its own `##` section.** When explaining an option or feature takes more than a sentence or two, such as function calling or output dimensions, give it a section between Errors and Examples and link to it from the options table. This keeps the reference sections short.
- **Usage patterns are examples.** A way of using the API, such as stopping a stream, goes in a runnable example that the relevant section links to ("See the [stop a stream example](/playground/ai-chat-stop-stream/)."), not in a section of its own.
- **Each example has a `###` heading** under `## Examples`, so every example shows in the table of contents.
+When you add a page, add it to [src/docs/src/sidebar.js](src/docs/src/sidebar.js) under its area, or it won't show up in the navigation. When you add a runnable example, add its HTML to `src/docs/src/playground/examples/<slug>.html`, register the slug in [src/docs/src/examples.js](src/docs/src/examples.js), and link the code block to it by putting the slug after the language with a semicolon (` ```html;kv-set `).

 ### Writing docs

 These apply to reference pages and recipes alike.

 - **Document the developer-facing side only.** The reader is building on top of puter.js, so cover what affects their code: signatures, defaults, return shapes, errors, limits, and behavior they can observe. Leave out internal workings (which service handles the call, storage layout, caching, retries) unless they change what the developer has to do. [rate-limits-and-quotas.md](src/docs/src/rate-limits-and-quotas.md) is the exception: it publishes every limit, including timeouts and caps that come from how the backend works.
- **Document Puter as it runs on puter.com.** The docs are for developers building on production Puter. Leave out behavior that only happens on a self-hosted or differently configured server, such as a provider that isn't set up there.
 - **Describe the current state.** Docs aren't a changelog. Write how the API behaves now, without "now", "no longer", "existing code is unaffected", or other wording that compares it to an older version.
 - **Verify before you document.** Run the calls you describe against a running Puter instead of inferring behavior from the source.
 - **Write plainly.** Use the literal words a developer would say out loud, with contractions and everyday words. No idioms or figurative verbs ("walk away from something shared with you" → "remove your own access", "nothing to page through" → "without pagination"). No formal register ("present only while more pages remain" → "includes a `cursor` if there are more pages to load"). Prefer dev terms such as atomic, concurrent, and insertion order.
@@ -202,7 +173,6 @@ These apply to reference pages and recipes alike.
 - **Describe behavior directly.** No quoted inner-voice phrases. Write "`isNew` is `true` when the person did not have access before", not "this tells 'I just gave this to someone' from 'they already had it'".
 - **Keep references easy to follow.** Name what a list or code block belongs to in the sentence directly above it. Name a thing once and keep that name. Introduce an actor as "a user" before giving them a role: "A user can create a team. The user who creates the team becomes its owner."
 - **Sentence mechanics.** Never start a sentence with inline code: write "To store data, use the [`set()`](/KV/set/) method." Link every inline mention of an API to its page, every time. No em dashes, and no colons or semicolons mid-sentence; a colon that introduces a code block is fine.
- **No `##` or `###` headings inside tabs.** The table of contents lists every `##` and `###` heading on the page, including the ones in a hidden tab (an `example-content` block switched by the `example-group` pills), so its links lead to content the reader can't see. Put the heading above the tabs, or use `####` inside a tab, which the table of contents skips.
 - **Show the correct way.** No "don't" and no wrong-way-first examples, in recipes and playground examples alike. Mention a wrong approach only when developers already hit it in practice, and state how it fails as a fact: "`add()` reads a plain object as a path map, so the call rejects with …".

 ### Recipes
@@ -231,6 +201,6 @@ Recipes are tested, copy-pasteable patterns for a task, one layer above the per-

 - **Reuse existing UI primitives before writing new ones.** Windows and dialogs are `UIWindow*` functions in [src/gui/src/UI/](src/gui/src/UI/); generic pieces already exist (`UIAlert`, `UIPrompt`, `UIContextMenu`, `UINotification`, `UIPopover`, widgets in [UI/Components/](src/gui/src/UI/Components/)). A new window should read like its neighbors: an async function taking an options object, composing an HTML string, wiring behavior with jQuery, delegating to `UIWindow(...)`.
 - **Match the visual language.** Use existing CSS classes (`button`, `button-primary`, window chrome, form styles) and copy the layout patterns of neighboring windows; new styles go in [src/gui/src/css/](src/gui/src/css/) following existing conventions. Verify anything positional (menus, overlays, z-index) on both desktop and mobile viewports.
- **i18n every user-facing string.** No hardcoded UI text — use `i18n('key')` and add the key to [src/gui/src/i18n/translations/en.js](src/gui/src/i18n/translations/en.js).
+- **i18n every user-facing string.** No hardcoded UI text — use `i18n('key')` and add the key to [src/gui/src/i18n/translations/en.js](src/gui/src/i18n/translations/en.js). Run `npm run check-translations` before opening the PR.
 - **Shared logic goes in helpers/services.** Reusable non-UI logic belongs in [src/gui/src/helpers/](src/gui/src/helpers/) or [src/gui/src/services/](src/gui/src/services/), not copy-pasted between windows.
 - **Tests.** Vitest is wired for the GUI (`src/**/*.test.js`; see [appOrder.test.js](src/gui/src/UI/Dashboard/appOrder.test.js) for the shape). Extract pure logic into functions and test those. Desktop behavior driven through puter.js (`puter.ui.*`) is covered by the Playwright harness in [src/puter-js/tests/e2e/](src/puter-js/tests/e2e/) — add a spec there when you change how the desktop renders SDK-driven UI.
@@ -73,12 +73,6 @@ COPY --from=build --chown=node:node /opt/puter .
 RUN mkdir -p /etc/puter /var/puter && \
    chown -R node:node /etc/puter /var/puter

-# Fix outdated HOME_URL in /etc/os-release (see issue #4329)
-# The base image may contain a reference to the old phoenix repository.
-RUN if [ -f /etc/os-release ]; then \
-      sed -i 's|HOME_URL="https://github.com/HeyPuter/phoenix"|HOME_URL="https://github.com/HeyPuter/puter"|' /etc/os-release; \
-    fi
-
 # Self-hosters mount their override at this exact path. The v2 loader
 # deep-merges it over config.default.json (see backend/index.ts).
 ENV PUTER_CONFIG_PATH=/etc/puter/config.json
@@ -93,4 +87,4 @@ USER node
 HEALTHCHECK --interval=30s --timeout=3s --start-period=30s --retries=3 \
    CMD wget --no-verbose --tries=1 --spider http://puter.localhost:4100/test || exit 1

-CMD ["node", "-r", "./dist/src/backend/telemetry.js", "./dist/src/backend/index.js"]
+CMD ["node", "-r", "./dist/src/backend/telemetry.js", "./dist/src/backend/index.js"]
@@ -1,171 +0,0 @@
-# Embedded app browser
-
-`GET /embed/apps` on the deployment's main GUI origin renders the same app browser
-as the dashboard's Apps tab, without the desktop or dashboard navigation.
-
-It supports search, paging, saved folders, and saved ordering. It uses the same
-installed-app and recommendation data as the dashboard, including the user's
-removed recommendations. Editing, adding, reordering, renaming, and uninstalling
-are disabled. Selecting an app opens it in a new browser tab at its own URL, the
-same way the dashboard does, and the host page stays open. The app's token isn't
-put in the URL: the app's SDK asks the embed for it once the tab loads, so the
-embed must still be open then. If the iframe is removed first, the app falls back
-to its normal sign-in. Apps that need the desktop (built-in and godmode apps,
-private apps the user can't open, or a failed token request) open `/app/<name>`
-on the GUI origin, cut off from the embed. Website shortcuts open their external
-destination with no opener.
-The embed follows the OS's light or dark setting. A host with a fixed theme adds
-`theme=dark` or `theme=light` to the fragment (`#user=<uuid>&theme=dark`), since
-Chromium doesn't pass an iframe's `color-scheme` on to the page inside it.
-Apps opened from the embed carry `utm_source=puter.com&utm_medium=referral&utm_campaign=app_browser_embed`;
-the desktop and dashboard send `utm_campaign=desktop` and `utm_campaign=dashboard`.
-
-## Session and framing
-
-The embed shows the GUI session only to the user the host page is signed in as.
-The host names that user's `uuid` (from `puter.auth.getUser()`) in the iframe
-URL's fragment, as `/embed/apps#user=<uuid>`. The embed reads the session, asks
-`/whoami` which user it belongs to, and shows the signed-out view unless the two
-match. So a host that names no user, a malformed one, or a user other than the
-session's, gets the signed-out view, and so does a session the API refuses. A
-failed `/whoami` check shows the error state. The fragment never reaches the
-server and can only narrow what the embed shows: naming the session's own user
-gives the same view as a direct visit to the GUI. Changing the fragment of a
-loaded embed reloads it.
-
-The embed reads the existing GUI session from local storage on its own origin.
-If that storage holds no session, the embed gets the session from the GUI origin's session cookie through
-`/get-gui-token`. This matters in Safari, which gives a framed origin separate
-local storage under each top-level origin, so even a sibling subdomain's iframe
-can't see the GUI's stored token. The session cookie is still sent, because the
-host is on the same site. The embed doesn't write that token back to storage. It
-does not create accounts, show a login dialog, or accept a token from its parent.
-Being signed in on a subdomain alone does not create a session on the main GUI
-origin.
-
-Without a session it can show, the embed shows the recommended apps (`RecommendedAppsService`)
-that the server put in the page, and nothing else: no installed apps, folders, or
-saved order, and no puter.js. Selecting one opens it at the same URL a signed-in
-launch uses, with no opener and no token on offer, so the app signs in on its own.
-Apps that need the desktop open `/app/<name>`. If the page carries no recommended
-apps, or a load fails, the embed displays an unavailable/error state.
-
-The route's `Content-Security-Policy: frame-ancestors` allows the GUI origin and
-the embedding page's origin when it is exactly one label under `config.domain`
-with the scheme and port from `config.origin`. Subdomains the server answers
-itself (`api`, `dav`, `js`, `www`, the native-app hosts, and the host of
-`api_base_url`) and the user-content hosting domains (`static_hosting_domain`,
-`private_app_hosting_domain`, and their `_alt` variants) are refused. For
-example, `https://puter.com` permits `https://spreadsheet.puter.com` but not
-`https://api.puter.com`, and `http://puter.localhost:4100` permits
-`http://spreadsheet.puter.localhost:4100` but not
-`http://someone.site.puter.localhost:4100`. The embedding page is read from the
-iframe request's referrer, so the host must not suppress it (the browser default
-`strict-origin-when-cross-origin` is enough). All ancestors in a nested iframe
-chain must be allowed. Other GUI routes retain `X-Frame-Options: SAMEORIGIN`.
-
-The embed accepts no query parameters. Requests with a query string redirect to
-the same embed path so SDK bootstrap parameters cannot override the session or API
-origin. The host needs to allow the GUI origin in its own `frame-src` CSP if it
-sets one. If sandboxing the iframe, allow scripts, same-origin storage, popups,
-and popups to escape the sandbox.
-
-## Host integration
-
-A first-party app that signs in with puter.js can place `<puter-user-menu>` from
-the SDK in its header instead (see `src/puter-js/src/ui/components.md`). It opens
-this embed with the signed-in user named and closes it when the app's sign-in
-changes. The rest of this section is for a host that builds the iframe itself.
-
-The iframe can be shown whether or not the user is signed in. Create it when
-“More apps” is opened, naming the signed-in user in its fragment, and remove it
-on close so reopening loads current apps and preferences. Remove it when the
-host's own sign-in changes too, such as on sign-out, so an open embed doesn't
-keep the previous user. The host owns the modal and close control;
-there is no parent messaging API and no app list or credential is sent to it.
-The app browser fills its iframe and responds to its size. It shows a spinner until its apps load.
-
-This example assumes `puterOrigin` comes from the host app's deployment
-settings. Translate the button and frame labels using the host app's
-localization system.
-
-```html
-<button id="more-apps" type="button">More apps</button>
-<dialog id="apps-dialog" aria-label="More apps">
-  <button id="close-apps" type="button">Close</button>
-  <div id="apps-frame"></div>
-</dialog>
-<style>
-  #apps-dialog { padding: 12px; width: min(900px, 90vw); }
-  #apps-frame iframe { width: 100%; height: min(650px, 75vh); border: 0; }
-</style>
-<script type="module">
-  const puterOrigin = 'https://puter.com'; // Use this deployment's configured origin.
-  const dialog = document.querySelector('#apps-dialog');
-  const container = document.querySelector('#apps-frame');
-  const trigger = document.querySelector('#more-apps');
-
-  trigger.addEventListener('click', async () => {
-    const url = new URL('/embed/apps', puterOrigin);
-    // Signed out, the embed shows the recommended apps.
-    const user = puter.auth.isSignedIn() ? await puter.auth.getUser().catch(() => null) : null;
-    if (user) url.hash = `user=${encodeURIComponent(user.uuid)}`;
-    const frame = document.createElement('iframe');
-    frame.title = 'Your apps';
-    frame.src = url.href;
-    container.replaceChildren(frame);
-    dialog.showModal();
-  });
-  document.querySelector('#close-apps').addEventListener('click', () => dialog.close());
-  dialog.addEventListener('close', () => {
-    container.replaceChildren();
-    trigger.focus();
-  });
-</script>
-```
-
-## Implementation
-
-`createAppBrowser` in `src/gui/src/UI/Dashboard/AppBrowser.js` owns the shared UI
-and data behavior; its `guestApps` option is the signed-out list. `TabApps.js`
-injects desktop actions. `appsEmbed.js` supplies new-tab launching through
-`launchAppInTab` (signed in) and `guestAppLaunchUrl` (signed out) in
-`src/gui/src/helpers/appTabLaunch.js`, which build the same app URL as
-`launch_app`, and loads only the embed entry, its SDK, and shared styles. `embedHostUser` in
-`src/gui/src/helpers/embedHostUser.js` reads the host's user from the fragment, and
-`embedHostTheme.js` beside it applies the host's theme.
-The normal GUI webpack build emits `bundle.min.js`, `apps-embed.min.js`, and `feedback-embed.min.js`.
-The `/embed/apps` route puts the recommended list in the page's config as
-`guestApps`. No puter.js API or app-list endpoint changes are needed.
-
-## Feedback dialog
-
-`GET /embed/feedback` is the app feedback dialog (`puter.ui.showFeedbackDialog()`)
-for a first-party page, with the same framing rules, query redirect, and
-host-user binding as `/embed/apps`. It sends the feedback for the framing
-page's origin, which the server reads from the referrer and pins with
-`frame-ancestors`; opened top-level, it does nothing. Its page is transparent
-so the dialog's own scrim covers the host.
-
-puter.js uses it on a page one label under the GUI origin when the page is
-signed in, framing it in a modal `<dialog>` that stays hidden until the embed
-is ready. The embed posts `{ msg: 'feedbackEmbed', state }` to its parent
-(`loading`, then `ready` or `unavailable`) and finally
-`{ msg: 'feedbackDialogClosed', sent }`. It reports `unavailable` without the
-named user's session, or while that user's email still needs confirming, and
-puter.js then uses the `/action/send-feedback` popup, which can sign in. So does
-a frame that never answers, such as one the host's CSP blocks. `feedbackEmbed.js`
-is the entry, sharing `embedSession` in `src/gui/src/helpers/embedSession.js`
-with the app browser; `showFeedbackEmbed` in `src/puter-js/src/lib/guiEmbed.js`
-is the host side.
-
-## Checks
-
-Run the GUI component/browser tests (with the SDK bundle built and Playwright
-Chromium installed), and the backend route tests:
-
-```sh
-npx vitest run --config src/gui/vitest.config.js src/gui/src/UI/Dashboard/AppBrowser src/feedbackEmbed
-npx vitest run src/puter-js/src/lib/guiEmbed.test.js src/puter-js/src/modules/UI.showFeedbackDialog.test.js
-npx vitest run --config src/backend/vitest.config.ts src/backend/server.test.ts
-```
@@ -59,13 +59,6 @@ store:
  row — and the query seeks past it (`WHERE (col, id) > (?, ?) ORDER BY col,
  id`). Any SQL list gaining a cursor must have a deterministic `ORDER BY`
  ending in a unique tiebreaker (`id`).
- The notification catch-up (`GET /events/fetch`) holds two keysets in one
-  sealed cursor: the last `id` it returned, and the last `(replaced_at, id)`
-  among rows up to that id. Each is its own indexed read, merged into one
-  page, so a row replaced after a client read it comes back from that cursor.
-  `from=end` with no cursor answers an empty page whose cursor holds the
-  slice's newest `id` and the slice's latest `(replaced_at, id)` as the
-  replacement mark.

 Cursors that carry a sort also pin it: a request that passes a cursor plus a
 conflicting sort is rejected with 400.
@@ -1,6 +1,6 @@
 # Browser push client

-Puter's desktop shows pushes through `/sw.js`. Core shows Settings → Notifications only when the `pushEnabled` gui param is `true`; core never sets it. The worker is registered only when push is turned on in the browser, and a load removes one left without a subscription. A backend extension that delivers pushes sets it with `services.homepage.setGuiParam('pushEnabled', true)` and can load its own code into the worker with `services.homepage.registerServiceWorkerScript(path)`.
+Puter's desktop shows pushes through `/sw.js`. Core registers it, and shows Settings → Notifications, only when the `pushEnabled` gui param is `true`; core never sets it. A backend extension that delivers pushes sets it with `services.homepage.setGuiParam('pushEnabled', true)` and can load its own code into the worker with `services.homepage.registerServiceWorkerScript(path)`.

 Core subscribes the browser to a push service only when the server also publishes `pushWebPushKey` (see [Built-in Web Push client](#built-in-web-push-client)), and it has no `/push/*` routes of its own. The device, app, preference and subscription endpoints below come from that extension. On a deployment without one, such as most self-hosted servers, they answer core's plain 404 (`code: 'not_found'`), which `puter.notifications` reports as `push_unavailable` and the Notifications tab shows as unavailable. A device the extension can't find is `device_not_found`.

@@ -18,18 +18,6 @@ Core subscribes the browser to a push service only when the server also publishe

 When the browser replaces the subscription (`pushsubscriptionchange`), `sw.js` posts `{ type: 'puter-push-subscription-changed' }` to every open window on Puter's origin. The worker has no token or session, so the page's push client registers the new subscription.

-## Receipts
-
-Before a notification is pushed, the server asks the open clients whether they received it live. It sends `notif.receipt` with `{ uid }` on the user's sockets for the app that sent it, or on the desktop's sockets for Puter's own notifications. The SDK remembers the uids its page received through `onNotification()`, `onPush()` or the desktop's feed, and answers once its page has that notification, or with `{ received: false }` when it never gets it. The server waits up to 5 seconds (`notificationAckTimeoutMs`).
-
-An answer carries `visibilityState` and `focused` as they were when the page received the notification. Pages never show a browser notification themselves; pushes do.
-
- An answer from a page that was visible and focused stops the push (`handled` on `notif.delivery.settled`). An older client that doesn't send `focused` counts while visible.
- Otherwise the notification is pushed, to every browser the user subscribed. A website's pushes go only to the browsers that subscribed through its own worker, never to Puter's `/sw.js`. An app inside the desktop pushes through `/sw.js`, which shows the app's name and icon.
- A client that can't answer, such as an older puter.js, doesn't hold the push back.
-
-The ask reaches only the sockets in the asking region. So that other regions hear about a page too, a page that receives a notification live while visible and focused also sends `notif.handled` with `{ uid }` on the socket it came on. Core relays it as the node-local `notif.handled` event with the socket's user and app, at most 60 a minute per user; an extension that delivers pushes decides what to do with it.
-
 ## Registering

 The registry is in [src/gui/src/helpers/pushClient.js](../src/gui/src/helpers/pushClient.js). A service script registers its client like this:
@@ -69,8 +57,8 @@ interface PushClient {
 }
 ```

- `enable()` may ask for notification permission, so core calls it from a click: Turn on in the Notifications tab, Allow on a permission prompt that includes `notifications:push` while this browser is off, and the "Turn on notifications" button of the `/action/enable-push` popup and the matching desktop dialog (`UIEnablePushDialog`). Core also calls it without a click, from `helpers/pushSync.js`, when `Notification.permission` is already `granted`, `status()` reports the browser as not registered, the user has not turned push off in this browser, and an app holds `notifications:push`; the browser does not prompt then. The built-in client runs `puter.notifications.enable()`, which subscribes with the `/sw.js` registration and registers the browser through the Web Push flow above (`platform: 'webpush'`). It then resolves the `uid` of this browser's `webpush` device from `listDevices()`. It rejects when permission is refused or the browser wasn't registered.
- `disable()` runs `puter.notifications.disable()`, which sends `DELETE /push/web/subscriptions { endpoint }` and ends the browser's subscription. The tab calls it for Turn off, and for Remove on the device marked as this browser. Remove on any other device is `DELETE /push/devices/:uid`.
+- `enable()` may ask for notification permission, so core calls it from a click: Turn on in the Notifications tab, Allow on a permission prompt that includes `notifications:push` while this browser is off, and the "Turn on notifications" button of the `/action/enable-push` popup and the matching desktop dialog (`UIEnablePushDialog`). Core also calls it without a click, from `helpers/pushSync.js`, when `Notification.permission` is already `granted`, `status()` reports the browser as not registered, the user has not turned push off in this browser, and an app holds `notifications:push`; the browser does not prompt then. It subscribes with the `/sw.js` registration, registers the device with `POST /push/devices` (`platform: 'web'`), and resolves the device `uid` the server returned. It rejects when permission is refused or the device couldn't be registered.
+- `disable()` unsubscribes and removes this browser's device with `DELETE /push/devices/:uid`. The tab calls it for Turn off, and for Remove on the device marked as this browser; Remove on any other device is a plain `DELETE`.
 - `status()` reports the state without prompting. `permission` is `Notification.permission`. `registered` is true when this browser has a device registered for the signed-in user, and `deviceUid` is that device's `uid`.

 After `enable()` resolves, the tab calls `POST /push/devices/:uid/test` and asks the user whether a notification showed up.
@@ -12,17 +12,7 @@ Generates secrets, writes `.env` + `puter/config/config.json`, downloads `docker

 ## Requirements

- **Docker** with the `compose` plugin. This is the one thing you have to install
-  yourself — the installer checks for it and stops with an explanation rather
-  than installing it for you.
-  - **macOS / Windows:** [Docker Desktop](https://docs.docker.com/get-docker/).
-    Both ship the `compose` plugin.
-  - **Linux:** [Docker Engine](https://docs.docker.com/engine/install/) plus the
-    [`docker-compose-plugin`](https://docs.docker.com/compose/install/) package.
-  - Confirm before running anything else: `docker compose version` should print a
-    version, not `command not found`.
-  - If Docker is installed but the shell can't see it, make sure your user is in
-    the `docker` group (Linux) or that Docker Desktop is actually running.
+- **Docker** with the `compose` plugin.
 - A **domain** with DNS access — you need a wildcard record (`*.your-domain.com` → server IP). Puter routes by subdomain (`api.<domain>`, `site.<domain>`, `app.<domain>`).
 - Optional: **TLS certs** (or `certbot` to grab them — see Step 3).

@@ -667,14 +657,6 @@ Migrations re-apply idempotently across pulls. Volumes are preserved.

 ## Troubleshooting

-**`missing required command: docker` — the installer stops immediately.**
-Docker isn't on your `PATH` yet. Puter self-hosting is a Docker Compose stack, so
-nothing can run without it. Install [Docker Desktop](https://docs.docker.com/get-docker/)
-on macOS/Windows or [Docker Engine](https://docs.docker.com/engine/install/) plus
-`docker-compose-plugin` on Linux, then confirm `docker compose version` works in
-the same shell and re-run the installer. On Linux, a fresh Docker install usually
-needs a new login session before your user picks up the `docker` group.
-
 **Site loads but I get a 502 / "Bad Gateway" from Caddy.**
 The puter container failed to come up. `docker compose logs puter` will tell you which dependency rejected it (most often DB password mismatch between `.env` and `config.json`).

@@ -53,29 +53,9 @@ need() {
    command -v "$1" >/dev/null 2>&1 || die "missing required command: $1"
 }

-check_docker() {
-    if command -v docker >/dev/null 2>&1; then
-        return 0
-    fi
-    echo >&2 ""
-    echo >&2 "[puter-install] missing required command: docker"
-    echo >&2 ""
-    echo >&2 "Docker is required to run Puter self-hosted."
-    echo >&2 ""
-    echo >&2 "Installation instructions:"
-    echo >&2 "  - macOS (Apple Silicon & Intel): https://docs.docker.com/desktop/setup/install/mac-install/"
-    echo >&2 "    (Docker Desktop is recommended. Alternatives: OrbStack, Colima)"
-    echo >&2 "  - Linux: https://docs.docker.com/engine/install/"
-    echo >&2 "  - Windows: https://docs.docker.com/desktop/setup/install/windows-install/"
-    echo >&2 ""
-    echo >&2 "After installing Docker, make sure it's running and try again."
-    echo >&2 ""
-    exit 1
-}
-
 # ── Step 1: dependency check ────────────────────────────────────────
 log "checking dependencies"
-check_docker
+need docker
 need curl
 need openssl
 docker compose version >/dev/null 2>&1 \
@@ -54,6 +54,7 @@
    "dev": "npm start",
    "build": "npm run setupExtensions && npm run build:ts && cd src/gui && node ./build.js && cd ../puter-js && npm run build",
    "build:workerLib": "cd src/puter-js && npm run build && cd ../worker && npm run build",
+    "check-translations": "node tools/check-translations.js",
    "prepare": "husky",
    "build:ts": "tsc -p tsconfig.build.json && node ./tools/write-dist-package-json.mjs",
    "check:puterjs:types": "node tools/checkPuterjsTypes.mjs",
@@ -78,8 +79,7 @@
    "javascript-time-ago": "^2.5.11",
    "libphonenumber-js": "1.13.15",
    "miniflare": "^4.20260617.1",
-    "open": "^10.1.0",
-    "sharp": "^0.35.5"
+    "open": "^10.1.0"
  },
  "engines": {
    "node": ">=24.0.0"
@@ -275,28 +275,6 @@ describe('AbstractDatabaseClient — SQL generation', () => {
        expect(postgres().timestampFromUnixSql()).toBe('to_timestamp(?)');
    });

-    it('reads a timestamp column back as unix seconds in each engine', () => {
-        expect(sqlite().unixSecondsSql('`t`')).toBe(
-            "CAST(strftime('%s', `t`) AS INTEGER)",
-        );
-        expect(mysql().unixSecondsSql('`t`')).toBe('UNIX_TIMESTAMP(`t`)');
-        expect(postgres().unixSecondsSql('`t`')).toBe(
-            'EXTRACT(EPOCH FROM `t`)::bigint',
-        );
-    });
-
-    it('reads the database clock as epoch milliseconds in each dialect', () => {
-        expect(sqlite().nowMsExpr()).toBe(
-            "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)",
-        );
-        expect(mysql().nowMsExpr()).toBe(
-            "(TIMESTAMPDIFF(MICROSECOND, '1970-01-01 00:00:00', UTC_TIMESTAMP(6)) DIV 1000)",
-        );
-        expect(postgres().nowMsExpr()).toBe(
-            'CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)',
-        );
-    });
-
    it('describes a stored timestamp the way each driver reads it back', () => {
        const seconds = Date.UTC(2026, 9, 11, 8, 5, 9) / 1000;
        expect(sqlite().timestampValue(seconds)).toBe('2026-10-11 08:05:09');
@@ -318,13 +296,3 @@ describe('AbstractDatabaseClient — SQL generation', () => {
        );
    });
 });
-
-
-it('builds an insert for batchWrite and shares it with insert', async () => {
-    const client = new FixtureDatabaseClient([]);
-    const entry = client.insertEntry('widget', { name: "reader's", enabled: true });
-    expect(entry.values).toEqual(["reader's", true]);
-    expect(entry.statement).toContain('VALUES (?, ?)');
-    await client.insert('widget', { name: "reader's", enabled: true });
-    expect(client.writes).toEqual([{ query: entry.statement, params: entry.values }]);
-});
@@ -110,23 +110,14 @@ export class AbstractDatabaseClient extends PuterClient {
        tableName: string,
        data: Record<string, unknown>,
    ): Promise<WriteResult> {
-        const entry = this.insertEntry(tableName, data);
-        return this.write(
-            entry.statement + this.returningIdClause(),
-            entry.values,
-        );
-    }
-
-    /** An insert that can join other writes in a transaction. */
-    insertEntry(tableName: string, data: Record<string, unknown>): BatchEntry {
        const cols = Object.keys(data);
-        return {
-            statement:
-                `INSERT INTO ${this.quoteIdentifier(tableName)} ` +
-                `(${cols.map((c) => this.quoteIdentifier(c)).join(', ')}) ` +
-                `VALUES (${cols.map(() => '?').join(', ')})`,
-            values: Object.values(data),
-        };
+        const values = Object.values(data);
+        const sql =
+            `INSERT INTO ${this.quoteIdentifier(tableName)} ` +
+            `(${cols.map((c) => this.quoteIdentifier(c)).join(', ')}) ` +
+            `VALUES (${cols.map(() => '?').join(', ')})` +
+            this.returningIdClause();
+        return this.write(sql, values);
    }

    /** Whether `read()` goes to a separate replica rather than the primary. */
@@ -397,34 +388,6 @@ export class AbstractDatabaseClient extends PuterClient {
        });
    }

-    /**
-     * A timestamp column as unix seconds, computed by the database: the mysql
-     * driver reads a stored UTC timestamp as local time, so parsing it in JS
-     * can be off by the server's UTC offset.
-     */
-    unixSecondsSql(column: string): string {
-        return this.case({
-            postgres: `EXTRACT(EPOCH FROM ${column})::bigint`,
-            mysql: `UNIX_TIMESTAMP(${column})`,
-            otherwise: `CAST(strftime('%s', ${column}) AS INTEGER)`,
-        });
-    }
-
-    /**
-     * The database's own clock as epoch milliseconds, so nodes whose clocks
-     * disagree still agree on it. The mysql form ignores the session time zone,
-     * so a DST change can't shift it.
-     */
-    nowMsExpr(): string {
-        return this.case({
-            sqlite: "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)",
-            postgres:
-                'CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)',
-            otherwise:
-                "(TIMESTAMPDIFF(MICROSECOND, '1970-01-01 00:00:00', UTC_TIMESTAMP(6)) DIV 1000)",
-        });
-    }
-
    /**
     * What a read of a timestamp column holding `seconds` returns: sqlite gives
     * back the UTC text it stored, mysql2 and pg a `Date` read in node's time
@@ -27,7 +27,7 @@ import { DatabaseClientFactory } from './index.js';
 import { SqliteDatabaseClient } from './SqliteDatabaseClient.js';

 /** Highest schema version the migration table can reach. */
-const CURRENT_SCHEMA_VERSION = 98;
+const CURRENT_SCHEMA_VERSION = 93;

 /**
 * These suites migrate real files on disk. Idle they finish in well under a
@@ -673,38 +673,6 @@ describe('SqliteDatabaseClient — boot and migrations', { timeout: DISK_MIGRATI
        });
    });

-    it('adds kv_share_handles.notify from 0099, off for every existing share', async () => {
-        const dir = mkdtempSync(join(tmpdir(), 'puter-sqlite-notify-'));
-        const path = join(dir, 'puter.sqlite');
-        try {
-            const before = new SqliteDatabaseClient(
-                sqliteConfig({ inMemory: false, path, targetVersion: 94 }),
-            );
-            await before.onServerStart();
-            await before.write(
-                'INSERT INTO `kv_share_handles` (`handle`, `owner_user_id`, ' +
-                    '`grantee_user_id`, `app_uid`, `key_prefix`, `permission`, ' +
-                    '`created_at`) VALUES (?, 1, 1, ?, ?, ?, 0)',
-                ['kvh-before-notify', 'os-global', 'a:', 'kv-share:x'],
-            );
-            before.onServerShutdown();
-
-            const after = new SqliteDatabaseClient(
-                sqliteConfig({ inMemory: false, path }),
-            );
-            await after.onServerStart();
-            await expect(
-                after.read(
-                    'SELECT `notify` FROM `kv_share_handles` WHERE `handle` = ?',
-                    ['kvh-before-notify'],
-                ),
-            ).resolves.toEqual([{ notify: 0 }]);
-            after.onServerShutdown();
-        } finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-
    it('indexes notification.created_at for the retention sweep', async () => {
        const rows = await client.read('PRAGMA index_list(`notification`)');
        expect(rows.map((r) => String(r.name))).toContain(
@@ -712,97 +680,6 @@ describe('SqliteDatabaseClient — boot and migrations', { timeout: DISK_MIGRATI
        );
    });

-    it('indexes notification.replaced_at per mailbox slice for catch-up', async () => {
-        const columns = await client.read(
-            'PRAGMA index_info(`idx_notification_replaced`)',
-        );
-        expect(columns.map((c) => String(c.name))).toEqual([
-            'user_id',
-            'audience',
-            'app_uid',
-            'replaced_at',
-        ]);
-    });
-
-    it('keeps notification.send_key unique', async () => {
-        const rows = await client.read('PRAGMA index_list(`notification`)');
-        expect(
-            rows.find((r) => r.name === 'idx_notification_send_key'),
-        ).toMatchObject({ unique: 1 });
-        const columns = await client.read(
-            'PRAGMA index_info(`idx_notification_send_key`)',
-        );
-        expect(columns.map((c) => String(c.name))).toEqual(['send_key']);
-    });
-
-    it('creates event_user_handlers with its unique and holder indexes', async () => {
-        const columns = await client.read(
-            'PRAGMA table_info(`event_user_handlers`)',
-        );
-        expect(columns.map((c) => String(c.name))).toEqual([
-            'id',
-            'app_uid',
-            'holder_user_id',
-            'name',
-            'source',
-            'source_hash',
-            'created_at',
-            'updated_at',
-            'scope_since',
-        ]);
-        const indexes = await client.read(
-            'PRAGMA index_list(`event_user_handlers`)',
-        );
-        expect(
-            indexes.find(
-                (i) => i.name === 'idx_event_user_handlers_app_holder_name',
-            ),
-        ).toMatchObject({ unique: 1 });
-        expect(
-            indexes.find((i) => i.name === 'idx_event_user_handlers_holder_app'),
-        ).toMatchObject({ unique: 0 });
-        const columnsOf = async (index: string) =>
-            (await client.read(`PRAGMA index_info(\`${index}\`)`)).map((c) =>
-                String(c.name),
-            );
-        expect(await columnsOf('idx_event_user_handlers_app_holder_name')).toEqual(
-            ['app_uid', 'holder_user_id', 'name'],
-        );
-        expect(await columnsOf('idx_event_user_handlers_holder_app')).toEqual([
-            'holder_user_id',
-            'app_uid',
-        ]);
-    });
-
-    it('leaves event_handlers as it was', async () => {
-        const columns = await client.read('PRAGMA table_info(`event_handlers`)');
-        expect(columns.map((c) => String(c.name))).toEqual([
-            'id',
-            'app_uid',
-            'name',
-            'source',
-            'source_hash',
-            'created_at',
-            'updated_at',
-        ]);
-    });
-
-    it('adds event_subscriptions.handler_scope, app scope for existing rows', async () => {
-        const columns = await client.read(
-            'PRAGMA table_info(`event_subscriptions`)',
-        );
-        expect(columns.find((c) => c.name === 'handler_scope')).toMatchObject({
-            notnull: 1,
-            dflt_value: '0',
-        });
-        const indexes = await client.read(
-            'PRAGMA index_list(`event_subscriptions`)',
-        );
-        expect(indexes.map((i) => String(i.name))).toContain(
-            'idx_event_subscriptions_holder',
-        );
-    });
-
    it('leaves an already-migrated database untouched on a second boot', async () => {
        const dir = mkdtempSync(join(tmpdir(), 'puter-sqlite-'));
        const path = join(dir, 'nested', 'puter.sqlite');
@@ -132,11 +132,6 @@ const AVAILABLE_MIGRATIONS: [number, string[]][] = [
    [90, ['0095_kv-share-handle-levels.sql']],
    [91, ['0096_kv-share-handle-quota-indexes.sql']],
    [92, ['0097_user-to-user-holder-permission-index.sql']],
-    [93, ['0098_notification-groups.sql']],
-    [94, ['0099_kv-share-handle-notify.sql']],
-    [95, ['0100_notification-send-key.sql']],
-    [96, ['0101_user-scoped-handlers.sql']],
-    [97, ['0102_notification-scope-id-index.sql']],
 ];

 export class SqliteDatabaseClient extends AbstractDatabaseClient {
@@ -1,53 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- `notification`.`group_key` and `replaced_at`. See
-- sqlite/0098_notification-groups.sql for the rationale. The key is a hex
-- digest, so ascii and compared byte for byte. No per-file applied-state
-- tracking, so every step is guarded and a replay does nothing.
-
-CALL _puter_add_col('notification', 'group_key', '`group_key` char(64) CHARACTER SET ascii COLLATE ascii_bin DEFAULT NULL');
-CALL _puter_add_col('notification', 'replaced_at', '`replaced_at` bigint DEFAULT NULL');
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_group_indexes;
-DELIMITER //
-CREATE PROCEDURE _puter_add_notification_group_indexes()
-BEGIN
-  IF NOT EXISTS (
-    SELECT 1 FROM INFORMATION_SCHEMA.STATISTICS
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = 'notification'
-      AND INDEX_NAME = 'idx_notification_group'
-  ) THEN
-    ALTER TABLE `notification` ADD INDEX `idx_notification_group`
-      (`user_id`, `app_uid`, `group_key`);
-  END IF;
-  IF NOT EXISTS (
-    SELECT 1 FROM INFORMATION_SCHEMA.STATISTICS
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = 'notification'
-      AND INDEX_NAME = 'idx_notification_replaced'
-  ) THEN
-    ALTER TABLE `notification` ADD INDEX `idx_notification_replaced`
-      (`user_id`, `audience`, `app_uid`, `replaced_at`);
-  END IF;
-END//
-DELIMITER ;
-
-CALL _puter_add_notification_group_indexes();
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_group_indexes;
@@ -1,23 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Notifications through a share handle. See
-- sqlite/0099_kv-share-handle-notify.sql for the column. No per-file
-- applied-state tracking, so it goes through _puter_add_col and a replay does
-- nothing.
-
-CALL _puter_add_col('kv_share_handles', 'notify', '`notify` tinyint(1) NOT NULL DEFAULT 0');
@@ -1,43 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- `notification`.`send_key`. See sqlite/0100_notification-send-key.sql for the
-- rationale. The key is a uuid, so ascii and compared byte for byte. No
-- per-file applied-state tracking, so every step is guarded and a replay does
-- nothing.
-
-CALL _puter_add_col('notification', 'send_key', '`send_key` char(36) CHARACTER SET ascii COLLATE ascii_bin DEFAULT NULL');
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_send_key_index;
-DELIMITER //
-CREATE PROCEDURE _puter_add_notification_send_key_index()
-BEGIN
-  IF NOT EXISTS (
-    SELECT 1 FROM INFORMATION_SCHEMA.STATISTICS
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = 'notification'
-      AND INDEX_NAME = 'idx_notification_send_key'
-  ) THEN
-    ALTER TABLE `notification` ADD UNIQUE KEY `idx_notification_send_key`
-      (`send_key`), ALGORITHM=INPLACE, LOCK=NONE;
-  END IF;
-END//
-DELIMITER ;
-
-CALL _puter_add_notification_send_key_index();
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_send_key_index;
@@ -1,66 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Handlers an app's user published into their own scope, kept apart from
-- `event_handlers` so code that predates them never reads them. See
-- sqlite/0101_user-scoped-handlers.sql for the column rationale.
--
-- Idempotent: `CREATE TABLE IF NOT EXISTS` with the indexes declared inline,
-- and a guarded column add. There is no per-file applied-state tracking, so a
-- replay has to be a no-op.
-
-CREATE TABLE IF NOT EXISTS `event_user_handlers` (
-    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
-    -- Matches `apps`.`uid` exactly, charset included, so an equality against
-    -- one never falls back to a conversion.
-    `app_uid` char(40) CHARACTER SET latin1 COLLATE latin1_swedish_ci NOT NULL,
-    `holder_user_id` int unsigned NOT NULL,
-    `name` varchar(128) NOT NULL,
-    `source` mediumtext NOT NULL,
-    `source_hash` char(64) NOT NULL,
-    `created_at` bigint NOT NULL,
-    `updated_at` bigint NOT NULL,
-    -- When the scope first held a handler; kept across handler churn, so the
-    -- rent sweep sees the scope's age, not its oldest remaining handler's.
-    `scope_since` bigint NOT NULL,
-    PRIMARY KEY (`id`),
-    UNIQUE KEY `idx_event_user_handlers_app_holder_name` (`app_uid`, `holder_user_id`, `name`),
-    KEY `idx_event_user_handlers_holder_app` (`holder_user_id`, `app_uid`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-
-- Guarded here rather than through `_puter_add_col`, so the file also applies
-- on its own to a database that never ran the earlier migrations.
-DROP PROCEDURE IF EXISTS _puter_add_event_subscriptions_handler_scope;
-DELIMITER //
-CREATE PROCEDURE _puter_add_event_subscriptions_handler_scope()
-BEGIN
-  IF NOT EXISTS (
-    SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = 'event_subscriptions'
-      AND COLUMN_NAME = 'handler_scope'
-  ) THEN
-    ALTER TABLE `event_subscriptions`
-      ADD COLUMN `handler_scope` tinyint unsigned NOT NULL DEFAULT 0,
-      ALGORITHM=INSTANT;
-  END IF;
-END//
-DELIMITER ;
-
-CALL _puter_add_event_subscriptions_handler_scope();
-
-DROP PROCEDURE IF EXISTS _puter_add_event_subscriptions_handler_scope;
@@ -1,41 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- `notification` (`user_id`, `audience`, `app_uid`, `id`). See
-- sqlite/0102_notification-scope-id-index.sql for the rationale. No per-file
-- applied-state tracking, so the index is added only when missing and a
-- replay does nothing.
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_scope_id_index;
-DELIMITER //
-CREATE PROCEDURE _puter_add_notification_scope_id_index()
-BEGIN
-  IF NOT EXISTS (
-    SELECT 1 FROM INFORMATION_SCHEMA.STATISTICS
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = 'notification'
-      AND INDEX_NAME = 'idx_notification_scope_id'
-  ) THEN
-    ALTER TABLE `notification` ADD INDEX `idx_notification_scope_id`
-      (`user_id`, `audience`, `app_uid`, `id`), ALGORITHM=INPLACE, LOCK=NONE;
-  END IF;
-END//
-DELIMITER ;
-
-CALL _puter_add_notification_scope_id_index();
-
-DROP PROCEDURE IF EXISTS _puter_add_notification_scope_id_index;
@@ -1,29 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- notification.group_key and replaced_at. See
-- sqlite/0098_notification-groups.sql for the rationale. Idempotent via IF NOT
-- EXISTS.
-
-ALTER TABLE notification ADD COLUMN IF NOT EXISTS group_key varchar(64) DEFAULT NULL;
-ALTER TABLE notification ADD COLUMN IF NOT EXISTS replaced_at bigint DEFAULT NULL;
-
-CREATE INDEX IF NOT EXISTS idx_notification_group
-    ON notification (user_id, app_uid, group_key);
-
-CREATE INDEX IF NOT EXISTS idx_notification_replaced
-    ON notification (user_id, audience, app_uid, replaced_at);
@@ -1,22 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Notifications through a share handle. See
-- sqlite/0099_kv-share-handle-notify.sql for the column. Idempotent via
-- IF NOT EXISTS; there is no per-file applied-state tracking.
-
-ALTER TABLE kv_share_handles ADD COLUMN IF NOT EXISTS notify smallint NOT NULL DEFAULT 0;
@@ -1,24 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- notification.send_key. See sqlite/0100_notification-send-key.sql for the
-- rationale. Idempotent via IF NOT EXISTS.
-
-ALTER TABLE notification ADD COLUMN IF NOT EXISTS send_key char(36) DEFAULT NULL;
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_notification_send_key
-    ON notification (send_key);
@@ -1,39 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Handlers an app's user published into their own scope. See
-- sqlite/0101_user-scoped-handlers.sql for the column rationale.
-- Idempotent via IF NOT EXISTS.
-
-CREATE TABLE IF NOT EXISTS event_user_handlers (
-    id BIGSERIAL PRIMARY KEY,
-    app_uid VARCHAR(40) NOT NULL,
-    holder_user_id INTEGER NOT NULL,
-    name VARCHAR(128) NOT NULL,
-    source TEXT NOT NULL,
-    source_hash VARCHAR(64) NOT NULL,
-    created_at BIGINT NOT NULL,
-    updated_at BIGINT NOT NULL,
-    scope_since BIGINT NOT NULL
-);
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_event_user_handlers_app_holder_name
-    ON event_user_handlers (app_uid, holder_user_id, name);
-CREATE INDEX IF NOT EXISTS idx_event_user_handlers_holder_app
-    ON event_user_handlers (holder_user_id, app_uid);
-
-ALTER TABLE event_subscriptions ADD COLUMN IF NOT EXISTS handler_scope smallint NOT NULL DEFAULT 0;
@@ -1,23 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- notification (user_id, audience, app_uid, id). See
-- sqlite/0102_notification-scope-id-index.sql for the rationale. Idempotent via
-- IF NOT EXISTS.
-
-CREATE INDEX IF NOT EXISTS idx_notification_scope_id
-    ON notification (user_id, audience, app_uid, id);
@@ -1,38 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- What app message groups need from `notification`:
--
--   - `group_key`   : a sha256 hex digest of an app message's `group`, so the
--                     notification a newer one replaces is found by index.
--                     Null on every other row, and on rows written before
--                     this, which therefore never match.
--   - `replaced_at` : epoch milliseconds of the last replacement, null for a
--                     row never replaced. Live and fetched copies carry it as
--                     their version, so a client can tell a replacement from a
--                     copy it already has. Indexed per mailbox slice, so a
--                     catch-up reads the rows replaced since its cursor
--                     without scanning the ones that never were.
-
-ALTER TABLE `notification` ADD COLUMN `group_key` TEXT DEFAULT NULL;
-ALTER TABLE `notification` ADD COLUMN `replaced_at` INTEGER DEFAULT NULL;
-
-CREATE INDEX IF NOT EXISTS `idx_notification_group`
-    ON `notification` (`user_id`, `app_uid`, `group_key`);
-
-CREATE INDEX IF NOT EXISTS `idx_notification_replaced`
-    ON `notification` (`user_id`, `audience`, `app_uid`, `replaced_at`);
@@ -1,23 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Whether the two parties of a share may send each other notifications through
-- its handle. Off by default, so every existing share reads as not allowing
-- them.
-
-ALTER TABLE `kv_share_handles`
-    ADD COLUMN `notify` INTEGER NOT NULL DEFAULT 0;
@@ -1,27 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- `notification`.`send_key`: the key of the delayed send (a `deferred`
-- schedule) that wrote this row or last replaced it, derived from the
-- schedule and its slot. Unique, so one slot can never write two rows, and a
-- send that crashed after writing finds its row again by it. Null on every row
-- a delayed send never touched.
-
-ALTER TABLE `notification` ADD COLUMN `send_key` TEXT DEFAULT NULL;
-
-CREATE UNIQUE INDEX IF NOT EXISTS `idx_notification_send_key`
-    ON `notification` (`send_key`);
@@ -1,48 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Handlers an app's user published into their own scope, in a table of their
-- own so `event_handlers` stays the app owner's set. Same columns as
-- `event_handlers` (see 0076_event-handlers.sql) plus the holder.
--
--   - `holder_user_id` : the user whose scope this is. A name is unique per
--                        (app, holder), so the same name can live in the app's
--                        set and in each holder's.
--   - `(holder_user_id, app_uid)` : a holder's scopes, for listing and for the
--                        rent count.
--
-- `event_subscriptions.handler_scope` says which table a row's `handler_name`
-- refers to: 0 the app's set, 1 the row holder's scope.
-
-CREATE TABLE IF NOT EXISTS `event_user_handlers` (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "app_uid" TEXT NOT NULL,
-    "holder_user_id" INTEGER NOT NULL,
-    "name" TEXT NOT NULL,
-    "source" TEXT NOT NULL,
-    "source_hash" TEXT NOT NULL,
-    "created_at" INTEGER NOT NULL,    -- unix seconds
-    "updated_at" INTEGER NOT NULL,
-    "scope_since" INTEGER NOT NULL    -- unix seconds; the scope's first handler, kept across churn
-);
-
-CREATE UNIQUE INDEX IF NOT EXISTS `idx_event_user_handlers_app_holder_name`
-    ON `event_user_handlers` (`app_uid`, `holder_user_id`, `name`);
-CREATE INDEX IF NOT EXISTS `idx_event_user_handlers_holder_app`
-    ON `event_user_handlers` (`holder_user_id`, `app_uid`);
-
-ALTER TABLE `event_subscriptions` ADD COLUMN `handler_scope` INTEGER NOT NULL DEFAULT 0;
@@ -1,22 +0,0 @@
-- Copyright (C) 2024-present Puter Technologies Inc.
--
-- This file is part of Puter.
--
-- Puter is free software: you can redistribute it and/or modify
-- it under the terms of the GNU Affero General Public License as published
-- by the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU Affero General Public License for more details.
--
-- You should have received a copy of the GNU Affero General Public License
-- along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-- Index a mailbox slice by row id, so a fetch finds the newest row of a slice,
-- and pages forward through one, with a seek rather than a scan of the slice.
-
-CREATE INDEX IF NOT EXISTS `idx_notification_scope_id`
-    ON `notification` (`user_id`, `audience`, `app_uid`, `id`);
@@ -75,15 +75,6 @@ export type EventMap = {
    serverStart: Record<string, never>;
    serverPrepareShutdown: Record<string, never>;
    serverShutdown: Record<string, never>;
-    /**
-     * Emitted by a host extension that knows this server will restart soon.
-     * Long-lived connections ask their clients to reconnect; nothing is refused
-     * or closed, so a false alarm is harmless.
-     */
-    serverRestartAnnounced: {
-        /** How long until the server stops, when known. */
-        closeInMs?: number;
-    };

    // ---- AI ----
    'ai.prompt.validate': {
@@ -117,7 +108,7 @@ export type EventMap = {
        model_used: string;
        service_used: string;
        intended_service: string;
-        model_details?: {
+        model_details: {
            id: string;
            provider: string;
            input_cost_key: string;
@@ -200,16 +191,6 @@ export type EventMap = {
    };

    // ---- Auth / signup ----
-    /**
-     * Which signup methods are open, emitted via `emitAndWait` before every
-     * signup and whenever the GUI reads the provider list. A listener sets
-     * `oidcOnly` to refuse form and temp signups, leaving OIDC and team
-     * provisioning open; `message` is what a refused form signup is told.
-     */
-    'puter.signup.policy': {
-        oidcOnly: boolean;
-        message: string | null;
-    };
    'puter.signup.validate': {
        allow: boolean;
        email?: string;
@@ -333,8 +314,6 @@ export type EventMap = {
        // the abuse extension cap sends per device (across accounts) so a
        // device farm can't dodge the per-account cap with fresh signups.
        device_fingerprint: string | null;
-        // Browser-signals dispatch id the client sent, or null.
-        dispatch_id: string | null;
        allowed: boolean;
        reason: string | null;
        // With `allowed` false, offer the card fallback in place of SMS. Only
@@ -556,14 +535,6 @@ export type EventMap = {
    'kv.share.retired': { handles: string[]; userId: number };

    // ---- Notifications ----
-    /** An app message was acknowledged after its state committed. */
-    'notif.acknowledged': {
-        userId: number;
-        uid: string;
-        type: string;
-        audience: string;
-        appUid: string;
-    };
    /**
     * A notification row exists. Emitted after the insert commits — nothing
     * pushes a uid before there is a row to name — and carries the scope tuple
@@ -578,8 +549,6 @@ export type EventMap = {
        appUid: string | null;
        value: Record<string, unknown>;
        createdAt: number;
-        /** An earlier notification replaced in place; `createdAt` is when. */
-        replaced?: true;
        /** Events handler runs behind whatever created it. */
        handlerDepth?: number;
    };
@@ -597,12 +566,8 @@ export type EventMap = {
        value: Record<string, unknown>;
        /** An earlier notification rewritten in place. */
        updated?: true;
-        /** Replaced an earlier notification in its group. */
-        replaced?: true;
        /** Names this one send, for a receipt asked about it. */
        sendId: string;
-        /** The same `sendId` may be emitted again, as a delayed send is. */
-        replayable?: true;
    };
    /**
     * One notification, addressed at whatever sockets each region holds for the
@@ -612,7 +577,7 @@ export type EventMap = {
     */
    'outer.notif.delivery': {
        userId: number;
-        wire: 'notif.message' | 'notif.unreads' | 'notif.ack' | 'notif.removed';
+        wire: 'notif.message' | 'notif.unreads' | 'notif.ack';
        response: unknown;
    };
    /**
@@ -636,18 +601,6 @@ export type EventMap = {
        /** A peer region holds a socket for the user. */
        peerRegions: boolean;
        responders: NotifDeliveryResponder[];
-        /** A page here got it live while visible and focused. */
-        handled: boolean;
-    };
-    /**
-     * A page reported that it got a notification live while visible and
-     * focused. Node-local; `appUid` is the reporting socket's app, absent for
-     * the desktop.
-     */
-    'notif.handled': {
-        userId: number;
-        appUid?: string;
-        uid: string;
    };

    // ---- Metering ----
@@ -698,18 +651,9 @@ export type EventMap = {
    // and going away (1→0, whether by removing the last handler or by the
    // destroy route). `actor.user` is the app's owner, not the caller — a
    // developer session publishing for an app it owns is the common case, but
-    // billing follows ownership. For `scope: 'user'` the unit is one user's
-    // handlers in one app instead, and `actor.user` is that user.
-    'events.worker.create': {
-        actor: Actor;
-        appUid: string;
-        scope: 'app' | 'user';
-    };
-    'events.worker.destroy': {
-        actor: Actor;
-        appUid: string;
-        scope: 'app' | 'user';
-    };
+    // billing follows ownership.
+    'events.worker.create': { actor: Actor; appUid: string };
+    'events.worker.destroy': { actor: Actor; appUid: string };

    // ---- Outer / GUI broadcast ----
    'outer.cacheUpdate': {
@@ -799,7 +743,6 @@ export type EventMap = {
    'outer.gui.item.renamed': GuiEvent;
    'outer.gui.notif.ack': GuiEvent<{ uid: string }>;
    'outer.gui.notif.message': GuiEvent<{ uid: string; notification: unknown }>;
-    'outer.gui.notif.removed': GuiEvent<{ uid: string }>;
    'outer.gui.notif.unreads': GuiEvent<{
        unreads: { uid: string; notification: unknown }[];
    }>;
@@ -873,12 +816,6 @@ export type EventMap = {
    /** One access token was revoked; only its own connections should drop. */
    'auth.access-token.revoked': { token_uid: string };

-    /** Same-cluster eviction for raw realtime WebSockets. */
-    'pubsub.realtime.auth-revoked': {
-        sessionUids?: string[];
-        tokenUid?: string;
-    };
-
    /**
     * A grant was withdrawn, so whatever was standing on it has to be settled
     * rather than left to fail its next check.
@@ -1001,9 +938,6 @@ export type AiCostFactorEvent = {
 */
 export type LifecyclePhase = 'before' | 'after' | 'error' | 'reject';

-/** Status a vetoing `before` listener may answer with. */
-export type LifecycleRejectStatus = 403 | 429;
-
 /**
 * Payload for `driver.<iface>.<method>.<phase>` events.
 *
@@ -1033,8 +967,6 @@ export type DriverMethodLifecycleEvent = {
    allow?: boolean;
    /** Optional human-readable reason surfaced to the caller when vetoed. */
    rejectReason?: string;
-    /** Status for a veto: 403 (default) or 429 for a throttle. */
-    rejectStatus?: LifecycleRejectStatus;
 };

 /**
@@ -1069,8 +1001,6 @@ export type RouteLifecycleEvent = {
    allow?: boolean;
    /** Optional human-readable reason surfaced to the caller when vetoed. */
    rejectReason?: string;
-    /** Status for a veto: 403 (default) or 429 for a throttle. */
-    rejectStatus?: LifecycleRejectStatus;
 };

 export type EventKey = keyof EventMap & string;
@@ -1079,11 +1009,10 @@ export type EventKey = keyof EventMap & string;
 // Generates a wildcard for every non-final dot-separated prefix of K.
 export type WildcardPrefixes<K extends string> =
    K extends `${infer Head}.${infer Tail}`
-        ?
-              | `${Head}.*`
-              | (Tail extends `${string}.${string}`
-                    ? `${Head}.${WildcardPrefixes<Tail>}`
-                    : never)
+        ? | `${Head}.*`
+          | (Tail extends `${string}.${string}`
+                ? `${Head}.${WildcardPrefixes<Tail>}`
+                : never)
        : never;

 export type ListenKey = EventKey | WildcardPrefixes<EventKey>;
@@ -1094,16 +1023,11 @@ export type MatchingEvents<P extends ListenKey> = P extends `${infer Prefix}.*`

 /** Acked, not acked, no socket anywhere, or sockets only in a peer region. */
 export type NotifDeliveryOutcome =
-    | 'received'
-    | 'unreceived'
-    | 'no-socket'
-    | 'remote-only';
+    'received' | 'unreceived' | 'no-socket' | 'remote-only';

 /** One socket's receipt for a live notification. */
 export interface NotifDeliveryResponder {
    visibilityState: 'visible' | 'hidden' | 'unknown';
-    /** The page's window has focus. Absent from older clients. */
-    focused?: boolean;
 }

 export type EventMetadata = {
@@ -42,10 +42,6 @@ import {
    adminOnlyGate,
    requireUserActorGate,
 } from '../../core/http/middleware/gates.js';
-import {
-    configureRateLimit,
-    listConfiguredRateLimitBackends,
-} from '../../core/http/middleware/rateLimit.js';
 import {
    ROUTES_METADATA_KEY,
    type CollectedRoute,
@@ -1757,40 +1753,6 @@ describe('AuthController.handleLoginOtp + handleLoginRecoveryCode', () => {
        ).rejects.toMatchObject({ statusCode: 400 });
    });

-    it('refuses the sign-in while the used-token store is down', async () => {
-        const { user, secret, otpToken } = await startOtpLogin();
-        const token = await otpToken();
-
-        const { default: backend } = listConfiguredRateLimitBackends();
-        configureRateLimit({
-            default: 'redis',
-            redis: {
-                multi: () => {
-                    throw new Error('store down');
-                },
-            },
-        });
-        const logged = vi.spyOn(console, 'error').mockImplementation(() => {});
-        const res = makeRes();
-        try {
-            await expect(
-                controller.handleLoginOtp(
-                    makeReq({ token, code: liveTotp(user.username, secret) }),
-                    res,
-                ),
-            ).rejects.toThrow('store down');
-        } finally {
-            logged.mockRestore();
-            configureRateLimit({
-                default: backend,
-                redis: server.clients.redis,
-                kv: server.stores.kv,
-                metering: server.services.metering,
-            });
-        }
-        expect(res.body).toBeUndefined();
-    });
-
    it('a wrong code leaves the token usable for a retry', async () => {
        const { user, secret, otpToken } = await startOtpLogin();
        const token = await otpToken();
@@ -5132,26 +5094,6 @@ describe('AuthController phone verification — staging & reuse', () => {
        expect(staged).toBe('+14155550123');
    });

-    it('makes an email-gate-last account verify its card before its phone', async () => {
-        const { user, actor } = await makeUserAndActor({
-            requires_phone_verification: 1,
-            requires_card_verification: 1,
-        });
-        await server.stores.user.updateMetadata(user.id, {
-            emailGateLast: true,
-        });
-        const prelude = stubPrelude();
-        await withClients({ prelude }, async () => {
-            await expect(
-                controller.handleSendConfirmPhone(
-                    makeReq({ phone: '+14155550123' }, { actor }),
-                    makeRes(),
-                ),
-            ).rejects.toMatchObject({ statusCode: 409 });
-        });
-        expect(prelude.createVerification).not.toHaveBeenCalled();
-    });
-
    it('forwards an abuse-extension veto as 429 with the opaque reason, and sends nothing', async () => {
        const { user, actor } = await makeUserAndActor();
        const emitAndWait = vi.fn(
@@ -5217,7 +5159,7 @@ describe('AuthController phone verification — staging & reuse', () => {
        );
    });

-    it('carries the client dispatch id on the check and sent events', async () => {
+    it('carries the client dispatch id on the sent signal', async () => {
        const { actor } = await makeUserAndActor();
        const emit = vi.fn();
        const emitAndWait = vi.fn(async () => {});
@@ -5238,11 +5180,6 @@ describe('AuthController phone verification — staging & reuse', () => {
            expect.objectContaining({ dispatch_id: 'disp-123' }),
            expect.anything(),
        );
-        expect(emitAndWait).toHaveBeenCalledWith(
-            'puter.phone-verification.check',
-            expect.objectContaining({ dispatch_id: 'disp-123' }),
-            expect.anything(),
-        );
    });

    it('does NOT emit the sent signal when the send fails upstream', async () => {
@@ -7750,46 +7687,6 @@ describe('AuthController permission revokes', () => {
        );
        expect(res.body).toEqual({});
    });
-
-    it('revoke-user-user: refuses a key-value share grant and leaves it standing', async () => {
-        const { actor: ownerActor, user: owner } = await makeUserAndActor();
-        const { user: holder } = await makeUserAndActor();
-        const permissions = ['kv-share', 'kv-share-read', 'kv-share-write'].map(
-            (root) => `${root}:${owner.uuid}:os-global:notes:${uuidv4()}`,
-        );
-        for (const permission of permissions)
-            await server.stores.permission.upsertUserUserPerm(
-                holder.id,
-                owner.id,
-                permission,
-                {},
-            );
-
-        for (const permission of permissions)
-            await expect(
-                inCtx(ownerActor, () =>
-                    controller.handleRevokeUserUser(
-                        makeReq(
-                            { target_username: holder.username, permission },
-                            { actor: ownerActor },
-                        ),
-                        makeRes(),
-                    ),
-                ),
-            ).rejects.toMatchObject({
-                statusCode: 400,
-                message: expect.stringContaining('puter.kv.unshare()'),
-            });
-        expect(
-            (
-                await server.stores.permission.findUserUserPermsByIssuer(
-                    holder.id,
-                    owner.id,
-                    permissions,
-                )
-            ).sort(),
-        ).toEqual([...permissions].sort());
-    });
 });

 // ── Permission checks + listing ────────────────────────────────────
@@ -66,7 +66,6 @@ import {
    isCardFallbackEnabled,
    phoneAttemptsKey,
 } from '../../util/cardFallback.js';
-import { isEmailGateLast } from '../../util/verificationOrder.js';
 import { sessionCookieFlags } from '../../util/cookieFlags.js';
 import { cleanEmail, isStorableEmail } from '../../util/email.js';
 import { isGodmodeApp } from '../../util/godmodeApps.js';
@@ -1221,18 +1220,6 @@ export class AuthController extends PuterController {
        }
    }

-    /** The email-gate-last confirmation email; a failure never fails the gate. */
-    private async sendDeferredConfirmation(userId: number): Promise<void> {
-        try {
-            await this.services.signup.sendDeferredConfirmationEmail(userId);
-        } catch (e) {
-            console.warn(
-                '[verification] deferred confirmation email failed:',
-                e,
-            );
-        }
-    }
-
    private async isCardFallbackEligible(user: {
        id: number;
        requires_phone_verification?: boolean | number | null;
@@ -1278,12 +1265,6 @@ export class AuthController extends PuterController {
            throw new HttpError(403, 'Account suspended.', {
                legacyCode: 'account_suspended',
            });
-        if (isEmailGateLast(user) && user.requires_card_verification)
-            throw new HttpError(
-                409,
-                'Card verification must be completed first.',
-                { legacyCode: 'conflict' },
-            );
        if (!this.clients.prelude?.isConfigured())
            throw await this.smsSendError(
                503,
@@ -1354,7 +1335,6 @@ export class AuthController extends PuterController {
            user_uid: user.uuid,
            phone: parsed.e164,
            device_fingerprint: req.deviceFingerprint ?? null,
-            dispatch_id: dispatchId ?? null,
            allowed: true,
            reason: null as string | null,
            card_fallback_instead: false,
@@ -1593,7 +1573,6 @@ export class AuthController extends PuterController {
            requires_phone_verification: 0,
            phone: pendingPhone,
        });
-        await this.sendDeferredConfirmation(user.id);

        // Run the verified-event listeners synchronously (emitAndWait, not
        // fire-and-forget emit) so a carrier-based card-verification waiver in
@@ -1674,11 +1653,7 @@ export class AuthController extends PuterController {
            res.json({ card_verified: true });
            return;
        }
-        if (
-            user.requires_phone_verification &&
-            !fallbackEligible &&
-            !isEmailGateLast(user)
-        )
+        if (user.requires_phone_verification && !fallbackEligible)
            throw new HttpError(
                409,
                'Phone verification must be completed first.',
@@ -1741,7 +1716,6 @@ export class AuthController extends PuterController {
            await this.stores.user.update(user.id, {
                requires_card_verification: 0,
            });
-            await this.sendDeferredConfirmation(user.id);
            res.json({ card_verified: true, disabled: true });
            return;
        }
@@ -1801,11 +1775,7 @@ export class AuthController extends PuterController {
            res.json({ card_verified: true });
            return;
        }
-        if (
-            user.requires_phone_verification &&
-            !fallbackEligible &&
-            !isEmailGateLast(user)
-        )
+        if (user.requires_phone_verification && !fallbackEligible)
            throw new HttpError(
                409,
                'Phone verification must be completed first.',
@@ -1846,7 +1816,6 @@ export class AuthController extends PuterController {
            await this.stores.user.update(user.id, {
                requires_card_verification: 0,
            });
-            await this.sendDeferredConfirmation(user.id);
            res.json({ card_verified: true, disabled: true });
            return;
        }
@@ -1871,7 +1840,6 @@ export class AuthController extends PuterController {
            requires_card_verification: 0,
            ...(clearedPhoneGate ? { requires_phone_verification: 0 } : {}),
        });
-        await this.sendDeferredConfirmation(user.id);

        // Awaited like `user.phone-verified`, so whatever a listener grants on
        // verification is in place before the client refreshes. emitAndWait
@@ -3336,14 +3304,6 @@ export class AuthController extends PuterController {
                { legacyCode: 'bad_request' },
            );
        }
-        // Only unsharing retires the handle along with its grant; withdrawing
-        // the grant alone would leave the share listed and dead.
-        if (typeof permission === 'string' && isKvSharePermission(permission))
-            throw new HttpError(
-                400,
-                'Stop a key-value share with `puter.kv.unshare()` (`DELETE /kv/shares/:handle`)',
-                { legacyCode: 'bad_request' },
-            );
        await this.services.permission.revokeUserUserPermission(
            req.actor!,
            target_username,
@@ -3850,9 +3810,8 @@ export class AuthController extends PuterController {

        let app = await this.stores.app.getByUid(app_uid);
        if (!app && resolvedFromOrigin) {
-            // Hosted-subdomain and custom-domain origins get the site owner
-            // stamped as the app's creator at bootstrap; external origins
-            // stay unowned.
+            // Hosted-subdomain origins get the site owner stamped as the
+            // app's creator at bootstrap; external origins stay unowned.
            // Canonical origin only, so alternate hosts share one row.
            const canonicalOrigin =
                this.services.auth.canonicalizeOrigin(origin);
@@ -3868,10 +3827,9 @@ export class AuthController extends PuterController {
            // An origin's uid is a deterministic uuidv5, so a deleted app
            // reappears here under the identical uid. Withdraw any cross-app
            // data grants left pointing at it before this new row can inherit
-            // consent the user gave its predecessor. Only `createFromOrigin`
-            // reuses a uid, here or wherever else an origin app is bootstrapped:
-            // `AppStore.create` mints a random uuid4, which no deleted app can
-            // ever hold again.
+            // consent the user gave its predecessor. Only *this* path can reuse
+            // a uid: `AppStore.create` mints a random uuid4, which no deleted
+            // app can ever hold again.
            //
            // Called directly rather than through `app.changed`: the token is
            // issued below, so this has to be able to stop that, and
@@ -3882,9 +3840,6 @@ export class AuthController extends PuterController {
                app_uid,
                'uid reused by a new app',
            );
-            // Key-value shares the predecessor left read as gone already,
-            // being older than this row; this only cleans them up.
-            this.services.kvShare.retireSharesOlderThanApp(app);
        }
        if (!app) {
            throw new HttpError(404, `App ${app_uid} does not exist`, {
@@ -4681,19 +4636,13 @@ export class AuthController extends PuterController {
        await checkRateLimit(`${scope}:${userUid}`, limit, window);
    }

-    /**
-     * An `otp-login` JWT completes one sign-in; a second redemption is refused.
-     * Fails closed: while the store can't say whether the token was used, the
-     * sign-in is refused rather than letting a captured token replay.
-     */
+    /** An `otp-login` JWT completes one sign-in; a second redemption is refused. */
    async #consumeOtpLoginToken(token: string): Promise<void> {
        const digest = crypto.createHash('sha256').update(token).digest('hex');
        const firstUse = await checkRateLimit(
            `login-otp-token-used:${digest}`,
            1,
            OTP_LOGIN_TOKEN_USED_WINDOW_MS,
-            undefined,
-            { failOpen: false },
        );
        if (!firstUse) {
            throw new HttpError(400, 'Invalid token.', {
@@ -19,7 +19,6 @@

 import type { Request, Response } from 'express';
 import { Controller, Post } from '../../core/http/decorators.js';
-import { schedulesUnavailable } from '../../core/schedules.js';
 import type { BroadcastService } from '../../services/broadcast/BroadcastService.js';
 import type { ForwardBatch } from '../../services/events/forwardQueue.js';
 import { PuterController } from '../types.js';
@@ -109,42 +108,6 @@ export class BroadcastController extends PuterController {
        );
        res.status(200).json({ ok: true, ...reply });
    }
-
-    /**
-     * Schedule changes a region made for schedules this one owns, handed to
-     * `services.schedules`; `events_disabled` on a server without it.
-     */
-    @Post('/events/schedules', { subdomain: '*' })
-    async schedules(req: Request, res: Response): Promise<void> {
-        const broadcast = this.services.broadcast as unknown as
-            BroadcastService | undefined;
-        if (!broadcast) {
-            res.status(503).json({
-                error: { message: 'Broadcast service not registered' },
-            });
-            return;
-        }
-
-        const verified = await broadcast.verifySignedRequest(
-            req.rawBody,
-            broadcastHeaders(req),
-        );
-        if (!verified.ok) {
-            res.status(verified.status ?? 400).json({
-                error: { message: verified.message ?? 'Bad request' },
-            });
-            return;
-        }
-        if (verified.info?.ignored) {
-            res.status(200).json({ ok: true, ...verified.info });
-            return;
-        }
-
-        const schedules = this.services.schedules;
-        if (!schedules) throw schedulesUnavailable();
-        const reply = await schedules.receivePeerChanges(req.body);
-        res.status(200).json({ ok: true, ...reply });
-    }
 }

 const broadcastHeaders = (req: Request) => {
@@ -736,42 +736,6 @@ describe('DriverController driver-method lifecycle events', () => {
            rejectReason: 'blocked in test',
        });
    });
-
-    it('answers 429 when a before listener vetoes with rejectStatus 429', async () => {
-        const actor = await makeUserActor();
-        await grantKvPerm(actor);
-        const key = `throttle-${uuidv4()}`;
-        server.clients.event.on(
-            'driver.puter-kvstore.set.before',
-            (_k, data) => {
-                if ((data.args as { key?: string })?.key === key) {
-                    data.allow = false;
-                    data.rejectStatus = 429;
-                }
-            },
-        );
-
-        const req = makeReq(
-            {
-                interface: 'puter-kvstore',
-                method: 'set',
-                args: { key, value: 'v' },
-            },
-            actor,
-        );
-        await expect(
-            runWithContext({ actor }, () =>
-                routes['POST /call'](
-                    req,
-                    makeRes() as unknown as Response,
-                    () => {},
-                ),
-            ),
-        ).rejects.toMatchObject({
-            statusCode: 429,
-            legacyCode: 'too_many_requests',
-        });
-    });
 });

 describe('DriverController.#handleListInterfaces', () => {
@@ -31,7 +31,6 @@ import {
    checkDriverRateLimit,
 } from '../../core/http/middleware/rateLimit.js';
 import type { PuterRouter } from '../../core/http/PuterRouter.js';
-import type { LifecycleRejectStatus } from '../../clients/event/types.js';
 import type { DriverMeta } from '../../drivers/meta.js';
 import {
    isCreditExhaustion,
@@ -335,8 +334,7 @@ export class DriverController extends PuterController {

        if (req.actor) {
            const permService = this.services.permission as unknown as
-                | PermissionService
-                | undefined;
+                PermissionService | undefined;
            if (permService) {
                // Build via PermissionUtil.join so any `:` in a driver or
                // interface name is escaped — raw interpolation would let a
@@ -477,7 +475,6 @@ export class DriverController extends PuterController {
            args,
            allow: true as boolean,
            rejectReason: undefined as string | undefined,
-            rejectStatus: undefined as LifecycleRejectStatus | undefined,
        };
        await this.clients.event?.emitAndWait(
            `driver.${ifaceName}.${method}.before`,
@@ -499,12 +496,11 @@ export class DriverController extends PuterController {
                },
                {},
            );
-            const throttled = beforeEvent.rejectStatus === 429;
            throw new HttpError(
-                throttled ? 429 : 403,
+                403,
                beforeEvent.rejectReason ??
                    `Blocked by policy: ${ifaceName}:${method}`,
-                { legacyCode: throttled ? 'too_many_requests' : 'forbidden' },
+                { legacyCode: 'forbidden' },
            );
        }

@@ -25,11 +25,6 @@ import { bodyRecord } from '../../core/http/requestBody.js';
 import { DURABLE_LIST_LIMIT_CAP } from '../../stores/events/DurableSubscriptionStore.js';
 import { EVENTS_WORKERS_LIST_LIMIT_CAP } from '../../stores/events/EventHandlerStore.js';
 import { KV_HANDLE_LIST_LIMIT_CAP } from '../../stores/events/KvShareHandleStore.js';
-import {
-    SCHEDULE_LIST_LIMIT_CAP,
-    schedulesUnavailable,
-    type ScheduleServiceContract,
-} from '../../core/schedules.js';
 import { normalizeLimit } from '../../util/pagination.js';
 import { PuterController } from '../types.js';
 import { EVENTS_WORKER_PREFIX } from '../../services/events/workerRuntime.js';
@@ -64,8 +59,6 @@ const EVENTS_SCRIPT_REGEX = new RegExp(`^${EVENTS_WORKER_PREFIX}[a-f0-9]{32}$`);

 /** Matches the edge dispatcher's own validation of the app uid it forwards. */
 const APP_UID_REGEX = /^app-[A-Za-z0-9_-]{1,64}$/;
-/** A user uuid. */
-const HOLDER_REGEX = /^[A-Za-z0-9-]{1,64}$/;

@Controller('/events')
 export class EventsController extends PuterController {
@@ -111,31 +104,12 @@ export class EventsController extends PuterController {
        });
    }

-    /**
-     * POST /events/subscriptions/update — replace one subscription's `context`
-     * in place. An id the caller does not hold reads as absent.
-     */
-    @Post('/subscriptions/update', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-    })
-    async update(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        const { sub } = await this.services.events.updateDurable(
-            actor,
-            bodyRecord(req),
-        );
-        res.json(sub);
-    }
-
    /**
     * GET /events/fetch — what the caller missed, one page at a time.
     *
     * Stateless: no subscription, no stored position, nothing written. The
     * cursor comes back to the caller and goes out again as `cursor` (or
-     * `after`, the name it first shipped under). `from=end` with no cursor
-     * starts at the newest row instead of the oldest.
+     * `after`, the name it first shipped under).
     */
    @Get('/fetch', {
        subdomain: 'api',
@@ -146,16 +120,9 @@ export class EventsController extends PuterController {
    async fetch(req: Request, res: Response): Promise<void> {
        const actor = this.#requireActor(req);
        const query = (req.query ?? {}) as Record<string, unknown>;
-        const from = query.from as 'start' | 'end' | undefined;
-        if (from !== undefined && from !== 'start' && from !== 'end') {
-            throw new HttpError(400, '`from` must be `start` or `end`', {
-                legacyCode: 'bad_request',
-            });
-        }

        const page = await this.services.events.fetchMissed(actor, {
            subject: typeof query.subject === 'string' ? query.subject : '',
-            from,
            cursor: typeof query.cursor === 'string' ? query.cursor : undefined,
            after: typeof query.after === 'string' ? query.after : undefined,
            limit: normalizeLimit(query.limit, {
@@ -184,99 +151,6 @@ export class EventsController extends PuterController {
        res.json({});
    }

-    // -- Schedules ---------------------------------------------------
-    //
-    // An app's handler run on a timer, served by `services.schedules` when a
-    // server has it and answered `events_disabled` when it doesn't. Creating
-    // one needs an app context; listing, reading and removing are scoped the
-    // way the durable verbs are. The create and remove verbs spend the
-    // subscribe and unsubscribe budgets in the service, shared with those
-    // verbs.
-
-    #schedules(): ScheduleServiceContract {
-        const schedules = this.services.schedules;
-        if (!schedules) throw schedulesUnavailable();
-        return schedules;
-    }
-
-    /** POST /events/schedules — create a schedule for the calling app. */
-    @Post('/schedules', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-    })
-    async createSchedule(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        res.json(await this.#schedules().createFor(actor, bodyRecord(req)));
-    }
-
-    /** GET /events/schedules — the caller's schedules, one page at a time. */
-    @Get('/schedules', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-        rateLimit: EVENTS_LIST_LIMIT,
-    })
-    async listSchedules(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        const query = (req.query ?? {}) as Record<string, unknown>;
-
-        const page = await this.#schedules().list(actor, {
-            limit: normalizeLimit(query.limit, {
-                cap: SCHEDULE_LIST_LIMIT_CAP,
-            }),
-            cursor: typeof query.cursor === 'string' ? query.cursor : undefined,
-            includeTotal: query.includeTotal === 'true',
-        });
-
-        res.json({
-            items: page.items,
-            ...(page.cursor ? { cursor: page.cursor } : {}),
-            ...(page.total !== undefined ? { total: page.total } : {}),
-        });
-    }
-
-    @Post('/schedules/update', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-    })
-    async updateSchedule(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        const { scheduleId, changes } = bodyRecord(req);
-        res.json(await this.#schedules().update(actor, scheduleId, changes));
-    }
-
-    /**
-     * POST /events/schedules/remove — end one schedule. An id the caller does
-     * not hold reads as absent.
-     */
-    @Post('/schedules/remove', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-    })
-    async removeSchedule(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        await this.#schedules().remove(actor, bodyRecord(req).scheduleId);
-        res.json({});
-    }
-
-    /**
-     * GET /events/schedules/:scheduleId — one schedule, ended or not. An id the
-     * caller does not hold reads as absent.
-     */
-    @Get('/schedules/:scheduleId', {
-        subdomain: 'api',
-        requireAuth: true,
-        allowAccessToken: true,
-        rateLimit: EVENTS_LIST_LIMIT,
-    })
-    async getSchedule(req: Request, res: Response): Promise<void> {
-        const actor = this.#requireActor(req);
-        res.json(await this.#schedules().get(actor, req.params.scheduleId));
-    }
-
    // -- Cross-user key-value handles --------------------------------

    /**
@@ -423,7 +297,6 @@ export class EventsController extends PuterController {
            handlers: await this.services.events.listHandlers(actor, {
                appUid:
                    typeof query.appUid === 'string' ? query.appUid : undefined,
-                scope: query.scope,
            }),
        });
    }
@@ -522,15 +395,6 @@ export class EventsController extends PuterController {
            throw new HttpError(400, 'Missing or invalid `script`/`appUid`', {
                legacyCode: 'bad_request',
            });
-        // Absent or empty is the app's own scope.
-        const holder = body.holder === undefined ? '' : body.holder;
-        if (
-            typeof holder !== 'string' ||
-            !(holder === '' || HOLDER_REGEX.test(holder))
-        )
-            throw new HttpError(400, 'Invalid `holder`', {
-                legacyCode: 'bad_request',
-            });

        const deployer = this.#eventsWorkerDeployer();
        if (!deployer.enabled) {
@@ -538,25 +402,15 @@ export class EventsController extends PuterController {
            return;
        }

-        const scope = await deployer.scopeFor(appUid, holder);
-        if (!scope) {
-            res.status(404).json({ deployed: false, reason: 'no-holder' });
-            return;
-        }
-
-        const outcome = await deployer.ensure(scope, script);
+        const outcome = await deployer.ensure(appUid, script);
        if (outcome === 'deployed') {
            res.json({ deployed: true });
            return;
        }
-        // `failed`, `throttled` and `busy` are worth another attempt: the rest
-        // say this script is not what the app's handlers currently are.
+        // `failed` and `throttled` are worth another attempt: the rest say
+        // this script is not what the app's handlers currently are.
        res.status(
-            outcome === 'failed' ||
-                outcome === 'throttled' ||
-                outcome === 'busy'
-                ? 502
-                : 404,
+            outcome === 'failed' || outcome === 'throttled' ? 502 : 404,
        ).json({
            deployed: false,
            reason: outcome,
@@ -577,22 +431,14 @@ export class EventsController extends PuterController {
    override onServerStart(): void {
        const deployer = this.#eventsWorkerDeployer();
        if (!deployer.enabled) return;
-        this.services.events.useEagerDeploy((scope, script) =>
-            deployer.deployEagerly(scope, script),
-        );
        if (this.config.workers?.localServer) {
            this.services.events.useWorkerTransport(
                new LocalEventsInvokeTransport(this.services, deployer),
            );
            return;
        }
-        this.services.events.useWorkerMissHandler(
-            async (appUid, script, options) => {
-                const scope = await deployer.scopeFor(appUid, options.holder);
-                return scope
-                    ? deployer.ensure(scope, script, options)
-                    : 'no-holder';
-            },
+        this.services.events.useWorkerMissHandler((appUid, script) =>
+            deployer.ensure(appUid, script),
        );
    }

@@ -34,46 +34,23 @@ import {
    EVENTS_DURABLE_SUBSCRIPTIONS_MAX,
    EVENTS_DURABLE_SUBSCRIPTIONS_PER_APP,
    EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER,
-    EVENTS_HANDLER_PUBLISH_LIMIT,
-    EVENTS_HANDLER_SOURCE_MAX_BYTES,
-    EVENTS_HANDLERS_PER_APP,
    EVENTS_KV_HANDLES_PER_APP,
    EVENTS_KV_HANDLES_PER_USER,
    EVENTS_KV_FILTER_EVALUATIONS_PER_EVENT,
    EVENTS_KV_MATCHED_SUBSCRIPTIONS_PER_EVENT,
    EVENTS_SINGLE_DELIVERY_LIMIT,
-    EVENTS_USER_HANDLERS_PER_SCOPE,
-    EVENTS_USER_SCOPE_SOURCE_MAX_BYTES,
-    EVENTS_USER_WORKER_DEPLOYS_PER_HOUR,
-    EVENTS_WORKER_DEPLOYS_PER_HOUR,
    EVENTS_WORKER_INVOCATION_LIMIT,
-    EVENTS_WORKER_SOURCE_MAX_BYTES,
-    RENTED_UNITS_PER_USER,
    limitFor,
-    tiered,
    type TieredLimit,
 } from './limits.js';

 const tiers: Array<[string, TieredLimit]> = [
-    [
-        'durable subscriptions per account',
-        EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER,
-    ],
+    ['durable subscriptions per account', EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER],
    ['durable subscriptions per app', EVENTS_DURABLE_SUBSCRIPTIONS_PER_APP],
    ['live share handles per account', EVENTS_KV_HANDLES_PER_USER],
    ['live share handles per app', EVENTS_KV_HANDLES_PER_APP],
 ];

-describe('tiered', () => {
-    it('gives paid plans the base, and the free and temporary tiers their own', () => {
-        const limit = tiered(30, 20, 10);
-        expect(limitFor(limit, null)).toBe(30);
-        expect(limitFor(limit, 'some_plan')).toBe(30);
-        expect(limitFor(limit, DEFAULT_FREE_SUBSCRIPTION)).toBe(20);
-        expect(limitFor(limit, DEFAULT_TEMP_SUBSCRIPTION)).toBe(10);
-    });
-});
-
 describe('the tiered subscription quotas', () => {
    it.each(tiers)('%s never lets a free tier exceed paid', (_name, tier) => {
        for (const n of Object.values(tier.bySubscription))
@@ -128,9 +105,9 @@ describe('the tiered subscription quotas', () => {
    });

    it('holds an unrecognised plan to the paid base', () => {
-        expect(
-            limitFor(EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER, 'some_plan'),
-        ).toBe(EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER.limit);
+        expect(limitFor(EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER, 'some_plan')).toBe(
+            EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER.limit,
+        );
        expect(limitFor(EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER, null)).toBe(
            EVENTS_DURABLE_SUBSCRIPTIONS_PER_USER.limit,
        );
@@ -154,9 +131,9 @@ describe('the delivery budgets', () => {
            expect(
                limitFor(EVENTS_KV_MATCHED_SUBSCRIPTIONS_PER_EVENT, plan),
            ).toBe(matched);
-            expect(limitFor(EVENTS_KV_FILTER_EVALUATIONS_PER_EVENT, plan)).toBe(
-                evaluated,
-            );
+            expect(
+                limitFor(EVENTS_KV_FILTER_EVALUATIONS_PER_EVENT, plan),
+            ).toBe(evaluated);
            expect(evaluated).toBeGreaterThanOrEqual(matched);
        }
    });
@@ -192,42 +169,3 @@ describe('the delivery budgets', () => {
        }
    });
 });
-
-describe('the handler limits', () => {
-    it('pins the app-scope numbers the quotas page lists', () => {
-        expect(EVENTS_HANDLERS_PER_APP).toBe(100);
-        expect(EVENTS_HANDLER_SOURCE_MAX_BYTES).toBe(64 * 1024);
-        expect(EVENTS_WORKER_SOURCE_MAX_BYTES).toBe(5 * 1024 * 1024);
-        expect(EVENTS_WORKER_DEPLOYS_PER_HOUR).toBe(30);
-        expect(EVENTS_HANDLER_PUBLISH_LIMIT.limit).toBe(60);
-        expect(EVENTS_HANDLER_PUBLISH_LIMIT.window).toBe(60_000);
-    });
-
-    it('pins the user-scope numbers the quotas page lists', () => {
-        expect(EVENTS_USER_HANDLERS_PER_SCOPE).toBe(20);
-        expect(EVENTS_USER_SCOPE_SOURCE_MAX_BYTES).toBe(1024 * 1024);
-        expect(EVENTS_USER_WORKER_DEPLOYS_PER_HOUR).toBe(10);
-    });
-
-    it('keeps a user scope tighter than an app scope', () => {
-        expect(EVENTS_USER_HANDLERS_PER_SCOPE).toBeLessThan(
-            EVENTS_HANDLERS_PER_APP,
-        );
-        expect(EVENTS_USER_SCOPE_SOURCE_MAX_BYTES).toBeLessThan(
-            EVENTS_WORKER_SOURCE_MAX_BYTES,
-        );
-        expect(EVENTS_USER_WORKER_DEPLOYS_PER_HOUR).toBeLessThan(
-            EVENTS_WORKER_DEPLOYS_PER_HOUR,
-        );
-    });
-
-    it('pins the rented-unit cap by plan', () => {
-        expect(RENTED_UNITS_PER_USER.limit).toBe(100);
-        expect(limitFor(RENTED_UNITS_PER_USER, DEFAULT_FREE_SUBSCRIPTION)).toBe(
-            16,
-        );
-        expect(limitFor(RENTED_UNITS_PER_USER, DEFAULT_TEMP_SUBSCRIPTION)).toBe(
-            16,
-        );
-    });
-});
@@ -53,12 +53,7 @@ export interface TieredLimit {
    bySubscription: Record<string, number>;
 }

-/** Paid, free and temporary caps as a {@link TieredLimit}. Called by extensions. */
-export const tiered = (
-    paid: number,
-    free: number,
-    temp: number,
-): TieredLimit => ({
+const tiered = (paid: number, free: number, temp: number): TieredLimit => ({
    limit: paid,
    bySubscription: {
        [DEFAULT_FREE_SUBSCRIPTION]: free,
@@ -98,18 +93,6 @@ export interface TieredQuota {
 */
 export const EVENTS_SESSION_SUBSCRIPTIONS_PER_SOCKET = 50;

-/**
- * Live subscriptions one user may hold through a share handle someone else
- * minted for them, across all of their connections.
- *
- * Those rows sit in the owner's keyspace, where each one costs a filter
- * evaluation on the owner's writes. The count also takes in connections that
- * dropped and haven't been reaped yet, so the cap sits far above what
- * reconnects leave behind. The owner's own rows through the handle don't
- * count.
- */
-export const EVENTS_SESSION_SUBSCRIPTIONS_PER_KV_HANDLE = 1000;
-
 /**
 * Durable subscriptions one account may hold, across every app.
 *
@@ -142,13 +125,6 @@ export const EVENTS_DURABLE_SUBSCRIPTIONS_MAX =
 */
 export const SUSPENDED_ROW_TTL_DAYS = 30;

-/**
- * Subscriptions stopped by a revoked grant that one account keeps for `list`.
- * They hold no quota slot, so past this the oldest are deleted when the account
- * subscribes again, keeping its rows bounded.
- */
-export const EVENTS_REVOKED_SUBSCRIPTIONS_KEPT = 500;
-
 /**
 * Subscribe calls per minute, per user.
 *
@@ -228,35 +204,17 @@ export const EVENTS_KV_HANDLES_PER_APP = tiered(10_000, 2_000, 0);
 export const EVENTS_KV_HANDLES_PER_HOLDER = 256;

 /**
- * Recipients one account may share with, per minute and per hour. A call spends
- * one per recipient that doesn't already hold the share, on top of the per-call
- * mint budget.
+ * Recipients one account may share with, per minute and per hour. A batch
+ * spends one per recipient, on top of the per-call mint budget.
 */
 export const KV_SHARE_GRANT_LIMITS = [
    userWindow('kvShare:grants:minute', 300),
    userWindow('kvShare:grants:hour', 2_000, 60 * 60_000),
 ] as const;

-/**
- * Recipients one account may name in share calls per minute, existing shares
- * included. Each one is looked up before the call knows whether it changes
- * anything, so a client that shares again on every load is bounded here.
- */
-export const KV_SHARE_LOOKUP_LIMIT = userWindow('kvShare:lookups', 1_200);
-
 /** Recipients one `POST /kv/shares` call may name. */
 export const KV_SHARE_BATCH_MAX = 50;

-/**
- * Notifications one party of a share may send the other through share handles,
- * per minute and per day, in one app. Keeps one share from spending the
- * recipient's whole notification allowance.
- */
-export const KV_SHARE_NOTIFY_LIMITS = [
-    userWindow('kvShare:notify:minute', 30),
-    userWindow('kvShare:notify:day', 500, 24 * 60 * 60_000),
-] as const;
-
 // -- Handler surface -------------------------------------------------

 /**
@@ -269,12 +227,6 @@ export const KV_SHARE_NOTIFY_LIMITS = [
 */
 export const EVENTS_HANDLERS_PER_APP = 100;

-/**
- * Handlers one user may hold in their own scope of one app. Each is a script of
- * its own, so the cap is tighter than the app's.
- */
-export const EVENTS_USER_HANDLERS_PER_SCOPE = 20;
-
 /** Longest a serialized handler may be. */
 export const EVENTS_HANDLER_SOURCE_MAX_BYTES = 64 * 1024;

@@ -286,9 +238,6 @@ export const EVENTS_HANDLER_SOURCE_MAX_BYTES = 64 * 1024;
 */
 export const EVENTS_WORKER_SOURCE_MAX_BYTES = 5 * 1024 * 1024;

-/** Source one user scope may hold, all its handlers combined. */
-export const EVENTS_USER_SCOPE_SOURCE_MAX_BYTES = 1024 * 1024;
-
 /**
 * Deploys one app's events worker may trigger per hour.
 *
@@ -298,16 +247,6 @@ export const EVENTS_USER_SCOPE_SOURCE_MAX_BYTES = 1024 * 1024;
 */
 export const EVENTS_WORKER_DEPLOYS_PER_HOUR = 30;

-/** Deploys one user scope may trigger per hour. */
-export const EVENTS_USER_WORKER_DEPLOYS_PER_HOUR = 10;
-
-/**
- * Units one user may rent at once: ordinary workers, user scopes, and the
- * events workers of apps they own. Only creating a unit is refused; holdings
- * over the cap are kept.
- */
-export const RENTED_UNITS_PER_USER = tiered(100, 16, 16);
-
 /**
 * Handlers one `publishAll` may carry. A build step publishes its whole set in
 * one call, and the set is capped by what an app may hold anyway.
@@ -372,11 +311,8 @@ export const EVENTS_KV_MATCHED_SUBSCRIPTIONS_PER_EVENT = tiered(512, 128, 128);
 */
 export const EVENTS_KV_FILTER_EVALUATIONS_PER_EVENT = tiered(2048, 512, 512);

-/**
- * Deliveries of one key-value change that carry its value inline, in the order
- * the fan-out serves them. Later ones carry the key alone.
- */
-export const EVENTS_KV_VALUE_DELIVERIES_PER_EVENT = 128;
+/** Omit all inline KV values when the matched audience exceeds this count. */
+export const EVENTS_KV_VALUE_OMIT_MATCHED_SUBSCRIPTIONS = 128;

 /**
 * Largest inline KV value in serialized bytes. Larger values are omitted;
@@ -468,20 +404,16 @@ export const EVENTS_REGION_PENDING_CEILING = 1_000_000;
 // a handler that answers "no" is not. Retrying on a fixed cadence turns one
 // broken deploy into a permanent load on whatever is failing, so the wait
 // doubles per attempt up to a ceiling, and a run of failures stops the
-// subscription rather than retrying it forever. A run Puter could not start or
-// finish backs off the same way but is not the handler's failure, so it never
-// counts toward that run.
+// subscription rather than retrying it forever.

-// Wait before the first retry of a delivery a handler could not take, the
-// longest wait, and the doubling between them. Shared with system jobs.
-export {
-    deliveryBackoffMs,
-    EVENTS_RETRY_BASE_MS,
-    EVENTS_RETRY_MAX_MS,
-} from '../../util/retryBackoff.js';
+/** Wait before the first retry of a delivery a handler could not take. */
+export const EVENTS_RETRY_BASE_MS = 2_000;
+
+/** Longest wait between retries, however many have failed. */
+export const EVENTS_RETRY_MAX_MS = 5 * 60 * 1000;

 /**
- * Handler failures in a row before a subscription is suspended. Counted per
+ * Failures in a row before a subscription is suspended. Counted per
 * subscription and reset by the first delivery a handler takes, so an
 * occasional failure never accumulates into one.
 */
@@ -494,6 +426,13 @@ export const EVENTS_CONSECUTIVE_FAILURES = 5;
 */
 export const EVENTS_FAILURE_COUNTER_TTL_MS = 60 * 60 * 1000;

+/** How long to hold a delivery whose handler has failed `attempts` times. */
+export const deliveryBackoffMs = (attempts: number): number =>
+    Math.min(
+        EVENTS_RETRY_MAX_MS,
+        EVENTS_RETRY_BASE_MS * 2 ** Math.max(0, attempts - 1),
+    );
+
 // -- Suspended backlog -----------------------------------------------
 //
 // A suspended subscription stops metering but keeps what it is owed, and that
@@ -1,289 +0,0 @@
-/*
- * Copyright (C) 2024-present Puter Technologies Inc.
- *
- * This file is part of Puter.
- *
- * Puter is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-/**
- * The schedule routes are thin delegates: without `services.schedules` every
- * one answers 503 `events_disabled`; with it, each hands its request over and
- * answers what it returns.
- */
-
-import type { Request, Response } from 'express';
-import {
-    afterAll,
-    afterEach,
-    beforeAll,
-    describe,
-    expect,
-    it,
-    vi,
-} from 'vitest';
-import { makeActor, type Actor } from '../../core/actor.js';
-import { isHttpError } from '../../core/http/HttpError.js';
-import type {
-    ScheduleServiceContract,
-    ScheduleView,
-} from '../../core/schedules.js';
-import type { PuterServer } from '../../server.js';
-import { setupTestServer } from '../../testUtil.js';
-import type { BroadcastController } from '../broadcast/BroadcastController.js';
-import type { EventsController } from './EventsController.js';
-
-let server: PuterServer;
-let events: EventsController;
-let broadcast: BroadcastController;
-let actor: Actor;
-let saved: unknown;
-
-const SCHEDULE_ID = '0b3a3c9e-9f61-4f0e-8d2a-2f1b6f8f2c11';
-
-const view = {
-    scheduleId: SCHEDULE_ID,
-    kind: 'recurring',
-    appUid: 'app-x',
-} as ScheduleView;
-
-const slot = () => server.services as unknown as { schedules?: unknown };
-/** Put `schedules` in the slot, or leave the slot empty. */
-const setSchedules = (schedules: unknown): void => {
-    if (schedules === undefined) delete slot().schedules;
-    else slot().schedules = schedules;
-};
-
-const fakeSchedules = () =>
-    ({
-        onSubscriptionsChanged: vi.fn(async () => {}),
-        createFor: vi.fn(async () => view),
-        list: vi.fn(async () => ({
-            items: [view],
-            cursor: 'next',
-            total: 3,
-        })),
-        get: vi.fn(async () => view),
-        update: vi.fn(async () => view),
-        remove: vi.fn(async () => {}),
-        receivePeerChanges: vi.fn(async () => ({ applied: 2 })),
-        prepareSendAt: vi.fn(),
-        createDeferredAppMessage: vi.fn(),
-    }) satisfies ScheduleServiceContract;
-
-const req = (init: {
-    body?: unknown;
-    query?: Record<string, unknown>;
-    params?: Record<string, string>;
-}): Request =>
-    ({
-        actor,
-        body: init.body ?? {},
-        query: init.query ?? {},
-        params: init.params ?? {},
-        headers: {},
-        rawBody: Buffer.from(JSON.stringify(init.body ?? {})),
-    }) as unknown as Request;
-
-const res = () => {
-    const sent: { status: number; body: unknown } = {
-        status: 200,
-        body: undefined,
-    };
-    const response = {
-        json: vi.fn((body: unknown) => {
-            sent.body = body;
-            return response;
-        }),
-        status: vi.fn((code: number) => {
-            sent.status = code;
-            return response;
-        }),
-        setHeader: vi.fn(() => response),
-    };
-    return { response: response as unknown as Response, sent };
-};
-
-/** Each route, called as the router would. */
-const routes: Array<[string, (response: Response) => Promise<void>]> = [
-    [
-        'POST /events/schedules',
-        (r) => events.createSchedule(req({ body: { every: 60_000 } }), r),
-    ],
-    [
-        'GET /events/schedules',
-        (r) => events.listSchedules(req({ query: { limit: '5' } }), r),
-    ],
-    [
-        'GET /events/schedules/:scheduleId',
-        (r) =>
-            events.getSchedule(req({ params: { scheduleId: SCHEDULE_ID } }), r),
-    ],
-    [
-        'POST /events/schedules/update',
-        (r) => events.updateSchedule(req({ body: { scheduleId: SCHEDULE_ID, changes: { every: '2h' } } }), r),
-    ],
-    [
-        'POST /events/schedules/remove',
-        (r) =>
-            events.removeSchedule(
-                req({ body: { scheduleId: SCHEDULE_ID } }),
-                r,
-            ),
-    ],
-    [
-        'POST /broadcast/events/schedules',
-        (r) =>
-            broadcast.schedules(
-                req({ body: { namespace: 'n', changes: [] } }),
-                r,
-            ),
-    ],
-];
-
-beforeAll(async () => {
-    server = await setupTestServer();
-    events = server.controllers.events as unknown as EventsController;
-    broadcast = server.controllers.broadcast as unknown as BroadcastController;
-    actor = makeActor({
-        user: { id: 1, uuid: 'u-1', username: 'someone' },
-    } as never);
-    saved = slot().schedules;
-    vi.spyOn(
-        server.services.broadcast,
-        'verifySignedRequest',
-    ).mockResolvedValue({ ok: true, peerId: 'peer' } as never);
-});
-
-afterEach(() => {
-    setSchedules(saved);
-});
-
-afterAll(async () => {
-    vi.restoreAllMocks();
-    await server?.shutdown();
-});
-
-describe('without services.schedules', () => {
-    it.each(routes)('%s answers 503 events_disabled', async (_name, call) => {
-        setSchedules(undefined);
-        const { response } = res();
-        let thrown: unknown;
-        try {
-            await call(response);
-        } catch (err) {
-            thrown = err;
-        }
-        expect(isHttpError(thrown)).toBe(true);
-        expect(thrown).toMatchObject({
-            statusCode: 503,
-            legacyCode: 'events_disabled',
-            // The designed answer, so it never pages.
-            noAlarm: true,
-        });
-    });
-
-    it('refuses an unsigned peer batch before saying schedules are off', async () => {
-        setSchedules(undefined);
-        vi.spyOn(
-            server.services.broadcast,
-            'verifySignedRequest',
-        ).mockResolvedValueOnce({
-            ok: false,
-            status: 401,
-            message: 'bad signature',
-        } as never);
-        const { response, sent } = res();
-        await broadcast.schedules(
-            req({ body: { namespace: 'n', changes: [] } }),
-            response,
-        );
-        expect(sent.status).toBe(401);
-    });
-});
-
-describe('with services.schedules', () => {
-    it('creates through createFor and answers its view', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        await events.createSchedule(req({ body: { every: 60_000 } }), response);
-        expect(schedules.createFor).toHaveBeenCalledWith(actor, {
-            every: 60_000,
-        });
-        expect(sent.body).toEqual(view);
-    });
-
-    it('lists with the limit capped, the cursor and includeTotal', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        await events.listSchedules(
-            req({
-                query: { limit: '5000', cursor: 'c', includeTotal: 'true' },
-            }),
-            response,
-        );
-        expect(schedules.list).toHaveBeenCalledWith(actor, {
-            limit: 200,
-            cursor: 'c',
-            includeTotal: true,
-        });
-        expect(sent.body).toEqual({ items: [view], cursor: 'next', total: 3 });
-    });
-
-    it('reads one through get', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        await events.getSchedule(
-            req({ params: { scheduleId: SCHEDULE_ID } }),
-            response,
-        );
-        expect(schedules.get).toHaveBeenCalledWith(actor, SCHEDULE_ID);
-        expect(sent.body).toEqual(view);
-    });
-
-    it('updates through update and answers its view', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        const changes = { every: '2h' };
-        await events.updateSchedule(req({ body: { scheduleId: SCHEDULE_ID, changes } }), response);
-        expect(schedules.update).toHaveBeenCalledWith(actor, SCHEDULE_ID, changes);
-        expect(sent.body).toEqual(view);
-    });
-
-    it('removes through remove and answers {}', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        await events.removeSchedule(
-            req({ body: { scheduleId: SCHEDULE_ID } }),
-            response,
-        );
-        expect(schedules.remove).toHaveBeenCalledWith(actor, SCHEDULE_ID);
-        expect(sent.body).toEqual({});
-    });
-
-    it('hands a signed peer batch to receivePeerChanges', async () => {
-        const schedules = fakeSchedules();
-        setSchedules(schedules);
-        const { response, sent } = res();
-        const body = { namespace: 'n', changes: [] };
-        await broadcast.schedules(req({ body }), response);
-        expect(schedules.receivePeerChanges).toHaveBeenCalledWith(body);
-        expect(sent).toEqual({ status: 200, body: { ok: true, applied: 2 } });
-    });
-});
@@ -1,77 +0,0 @@
-import type { Request, Response } from 'express';
-import { describe, expect, it } from 'vitest';
-import { makeActor } from '../../core/actor.js';
-import type {
-    ScheduleServiceContract,
-    ScheduleView,
-} from '../../core/schedules.js';
-import { EventsController } from './EventsController.js';
-
-const actor = makeActor({
-    user: { id: 1, uuid: 'user-1', username: 'user1' } as never,
-});
-const request = (body: unknown) => ({ actor, body }) as Request;
-const controller = (schedules?: Pick<ScheduleServiceContract, 'update'>) =>
-    new EventsController(
-        {} as never,
-        {} as never,
-        {} as never,
-        { schedules } as never,
-        {} as never,
-    );
-
-describe('update schedule route contract', () => {
-    it('answers events_disabled when schedules are unavailable', async () => {
-        await expect(
-            controller().updateSchedule(
-                request({ scheduleId: 'id', changes: {} }),
-                {} as Response,
-            ),
-        ).rejects.toMatchObject({
-            legacyCode: 'events_disabled',
-            statusCode: 503,
-            noAlarm: true,
-        });
-    });
-
-    it('passes the actor, id and changes through and returns the updated view', async () => {
-        const view = {
-            scheduleId: 'id',
-            kind: 'recurring',
-            state: 'suspended',
-        } as ScheduleView;
-        const changes = { cron: '0 9 * * *', tz: 'UTC' };
-        const calls: unknown[][] = [];
-        const events = controller({
-            update: async (...args) => {
-                calls.push(args);
-                return view;
-            },
-        });
-        let sent: unknown;
-        await events.updateSchedule(request({ scheduleId: 'id', changes }), {
-            json: (value: unknown) => {
-                sent = value;
-            },
-        } as Response);
-        expect(calls).toEqual([[actor, 'id', changes]]);
-        expect(sent).toBe(view);
-    });
-
-    it('preserves validation and sending errors from the implementation', async () => {
-        const error = {
-            code: 'events_schedule_sending',
-            message: 'Already sending',
-        };
-        await expect(
-            controller({
-                update: async () => {
-                    throw error;
-                },
-            }).updateSchedule(
-                request({ scheduleId: 'id', changes: {} }),
-                {} as Response,
-            ),
-        ).rejects.toBe(error);
-    });
-});
@@ -25,35 +25,9 @@

 import MockRedis from 'ioredis-mock';
 import { describe, expect, it } from 'vitest';
-import type { fetch as undiciFetch } from 'undici';
-import {
-    DispatcherInvokeTransport,
-    EVENTS_DEPLOYED_HEADER,
-    EVENTS_DISPATCH_ERROR_HEADER,
-    EVENTS_HANDLED_HEADER,
-    EventsWorkerInvokerClient,
-    type EventsInvokeCall,
-} from '../../clients/events/EventsWorkerInvokerClient.js';
-import { INTERNAL_DEPLOY_TARGET } from '../../drivers/workers/WorkerDriver.js';
-import {
-    EVENTS_USER_WORKER_DEPLOYS_PER_HOUR,
-    EVENTS_WORKER_DEPLOYS_PER_HOUR,
-} from './limits.js';
-import {
-    EventsWorkerDeployer,
-    LocalEventsInvokeTransport,
-    type EventsDeployOptions,
-    type EventsDeployOutcome,
-} from './workerDeploy.js';
-import {
-    eventsWorkerScript,
-    userHandlerScript,
-} from '../../services/events/workerRuntime.js';
-import {
-    appHandlerScope,
-    hashContent,
-    type HandlerScope,
-} from '../../stores/events/EventHandlerStore.js';
+import { EVENTS_WORKER_DEPLOYS_PER_HOUR } from './limits.js';
+import { EventsWorkerDeployer } from './workerDeploy.js';
+import { eventsWorkerScript } from '../../services/events/workerRuntime.js';
 import { handlerSetHash } from '../../services/events/workerSource.js';
 import type { IConfig } from '../../types.js';

@@ -72,22 +46,12 @@ interface Owner {
 type Layers = ConstructorParameters<typeof EventsWorkerDeployer>[0];

 /** Stub layers whose only real dependency is a fresh redis mock. */
-const makeLayers = (
-    owners: Record<string, Owner | null>,
-    events: Record<string, unknown> = {},
-) => {
+const makeLayers = (owners: Record<string, Owner | null>) => {
    const redis = new MockRedis.Cluster(['redis://localhost:7001']);
    const created: string[] = [];
-    const targets: Array<Record<string, unknown>> = [];
-    /** Apps whose handler sources were read, once per read. */
-    const sourceReads: string[] = [];
    const layers = {
        config: {
-            events: {
-                workerRuntime: true,
-                internalSecret: 'sekret',
-                ...events,
-            },
+            events: { workerRuntime: true, internalSecret: 'sekret' },
            // `#namespace()` needs a local-worker shape to resolve without
            // throwing — this stub never reaches a real Cloudflare or
            // Miniflare deploy either way.
@@ -96,20 +60,16 @@ const makeLayers = (
        clients: { redis },
        stores: {
            eventHandler: {
-                setForApp: async () => [{ name: 'h', sourceHash: SOURCE_HASH }],
-                allForApp: async ({ appUid }: { appUid: string }) => {
-                    sourceReads.push(appUid);
-                    return [
-                        {
-                            appUid,
-                            name: 'h',
-                            source: 'async () => {}',
-                            sourceHash: SOURCE_HASH,
-                            createdAt: 0,
-                            updatedAt: 0,
-                        },
-                    ];
-                },
+                allForApp: async (appUid: string) => [
+                    {
+                        appUid,
+                        name: 'h',
+                        source: 'async () => {}',
+                        sourceHash: SOURCE_HASH,
+                        createdAt: 0,
+                        updatedAt: 0,
+                    },
+                ],
            },
            app: {
                getByUid: async (appUid: string) => {
@@ -120,18 +80,6 @@ const makeLayers = (
                },
            },
            user: {
-                getByUuid: async (uuid: string) => {
-                    const owner = Object.values(owners).find(
-                        (o) => `uuid-${o?.ownerUserId}` === uuid,
-                    );
-                    if (!owner) return null;
-                    return {
-                        id: owner.ownerUserId,
-                        uuid,
-                        username: `user-${owner.ownerUserId}`,
-                        suspended: owner.suspended ?? false,
-                    };
-                },
                getById: async (id: number) => {
                    const owner = Object.values(owners).find(
                        (o) => o?.ownerUserId === id,
@@ -149,24 +97,14 @@ const makeLayers = (
        services: {},
        drivers: {
            workers: {
-                create: async (args: {
-                    workerName: string;
-                    [INTERNAL_DEPLOY_TARGET]?: Record<string, unknown>;
-                }) => {
+                create: async (args: { workerName: string }) => {
                    created.push(args.workerName);
-                    targets.push(args[INTERNAL_DEPLOY_TARGET] ?? {});
                    return { success: true, errors: [] };
                },
            },
        },
    };
-    return {
-        layers: layers as unknown as Layers,
-        created,
-        targets,
-        redis,
-        sourceReads,
-    };
+    return { layers: layers as unknown as Layers, created, redis };
 };

 describe('EventsWorkerDeployer.ensure', () => {
@@ -182,17 +120,15 @@ describe('EventsWorkerDeployer.ensure', () => {
        const deployer = new EventsWorkerDeployer(layers);

        const [a, b] = await Promise.all([
-            deployer.ensure(appHandlerScope('app-a'), SCRIPT),
-            deployer.ensure(appHandlerScope('app-b'), SCRIPT),
+            deployer.ensure('app-a', SCRIPT),
+            deployer.ensure('app-b', SCRIPT),
        ]);
        expect(a).toBe('deployed');
        expect(b).toBe('no-owner');
    });

-    it('refuses once the app has deployed past the hourly cap, before reading or building any source', async () => {
-        const { layers, redis, sourceReads, created } = makeLayers({
-            'app-c': { ownerUserId: 3 },
-        });
+    it('refuses once the app has deployed past the hourly cap', async () => {
+        const { layers, redis } = makeLayers({ 'app-c': { ownerUserId: 3 } });
        const deployer = new EventsWorkerDeployer(layers);
        const hour = new Date().toISOString().slice(0, 13);
        await redis.set(
@@ -200,697 +136,12 @@ describe('EventsWorkerDeployer.ensure', () => {
            String(EVENTS_WORKER_DEPLOYS_PER_HOUR),
        );

-        expect(await deployer.ensure(appHandlerScope('app-c'), SCRIPT)).toBe(
-            'throttled',
-        );
-        expect(sourceReads).toEqual([]);
-        expect(created).toEqual([]);
-    });
-
-    it('answers a stale script without spending the hourly cap', async () => {
-        const { layers, redis, sourceReads } = makeLayers({
-            'app-e': { ownerUserId: 5 },
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-        const stale = eventsWorkerScript(
-            handlerSetHash([{ name: 'h', sourceHash: 'b'.repeat(64) }]),
-            '',
-        );
-
-        expect(await deployer.ensure(appHandlerScope('app-e'), stale)).toBe(
-            'stale',
-        );
-        expect(sourceReads).toEqual([]);
-        const hour = new Date().toISOString().slice(0, 13);
-        expect(await redis.get(`ev:deploys:{app-e}:${hour}`)).toBeNull();
-    });
-
-    it('passes events.workerCpuMs to the deploy target', async () => {
-        const { layers, targets } = makeLayers(
-            { 'app-f': { ownerUserId: 6 } },
-            { workerCpuMs: 50 },
-        );
-        const deployer = new EventsWorkerDeployer(layers);
-        expect(await deployer.ensure(appHandlerScope('app-f'), SCRIPT)).toBe(
-            'deployed',
-        );
-        expect(targets[0]!.cpuMs).toBe(50);
-    });
-
-    it('passes no cpuMs when events.workerCpuMs is unset', async () => {
-        const { layers, targets } = makeLayers({ 'app-g': { ownerUserId: 7 } });
-        const deployer = new EventsWorkerDeployer(layers);
-        expect(await deployer.ensure(appHandlerScope('app-g'), SCRIPT)).toBe(
-            'deployed',
-        );
-        expect(targets[0]!.cpuMs).toBeUndefined();
+        expect(await deployer.ensure('app-c', SCRIPT)).toBe('throttled');
    });

    it('deploys normally under the cap', async () => {
        const { layers } = makeLayers({ 'app-d': { ownerUserId: 4 } });
        const deployer = new EventsWorkerDeployer(layers);
-        expect(await deployer.ensure(appHandlerScope('app-d'), SCRIPT)).toBe(
-            'deployed',
-        );
-    });
-});
-
-/** A server's schedules with a deploy gate that records and can refuse. */
-const withGate = (
-    layers: Layers,
-    refuse: (capped: boolean) => boolean = () => false,
-) => {
-    const gated: Array<{ script: string; capped: boolean }> = [];
-    const gate = {
-        gateDeploy: async (
-            script: string,
-            options: { capped: boolean },
-            deploy: () => Promise<EventsDeployOutcome>,
-        ): Promise<EventsDeployOutcome> => {
-            gated.push({ script, capped: options.capped });
-            return refuse(options.capped) ? 'busy' : deploy();
-        },
-    };
-    const deployer = new EventsWorkerDeployer({
-        ...layers,
-        services: { ...layers.services, schedules: gate },
-    } as unknown as Layers);
-    return { deployer, gated };
-};
-
-describe('the schedules` deploy gate', () => {
-    it('is skipped without schedules, or with schedules that have no gate', async () => {
-        const { layers, created } = makeLayers({ 'app-x': { ownerUserId: 1 } });
-        await expect(
-            new EventsWorkerDeployer(layers).ensure(
-                appHandlerScope('app-x'),
-                SCRIPT,
-                {
-                    lane: 'schedule',
-                },
-            ),
-        ).resolves.toBe('deployed');
-        const gateless = new EventsWorkerDeployer({
-            ...layers,
-            services: { ...layers.services, schedules: {} },
-        } as unknown as Layers);
-        await expect(
-            gateless.ensure(appHandlerScope('app-x'), SCRIPT, {
-                lane: 'schedule',
-            }),
-        ).resolves.toBe('deployed');
-        expect(created).toEqual([SCRIPT, SCRIPT]);
-    });
-
-    it('takes every deploy, capped only for a schedule run', async () => {
-        const { layers, created } = makeLayers({ 'app-x': { ownerUserId: 1 } });
-        const { deployer, gated } = withGate(layers);
-
-        await expect(
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT),
-        ).resolves.toBe('deployed');
-        await expect(
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT, {
-                lane: 'schedule',
-            }),
-        ).resolves.toBe('deployed');
-        expect(gated).toEqual([
-            { script: SCRIPT, capped: false },
-            { script: SCRIPT, capped: true },
-        ]);
-        expect(created).toEqual([SCRIPT, SCRIPT]);
-    });
-
-    it('answers a refused schedule run busy, and a delivery still deploys', async () => {
-        const { layers, created } = makeLayers({ 'app-x': { ownerUserId: 1 } });
-        const { deployer } = withGate(layers, (capped) => capped);
-
-        await expect(
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT, {
-                lane: 'schedule',
-            }),
-        ).resolves.toBe('busy');
-        await expect(
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT),
-        ).resolves.toBe('deployed');
-        expect(created).toEqual([SCRIPT]);
-    });
-
-    it('lets deliveries that join a schedule run`s refused deploy deploy once', async () => {
-        const { layers, created } = makeLayers({ 'app-x': { ownerUserId: 1 } });
-        const { deployer, gated } = withGate(layers, (capped) => capped);
-
-        const scheduled = deployer.ensure(appHandlerScope('app-x'), SCRIPT, {
-            lane: 'schedule',
-        });
-        const deliveries = [
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT),
-            deployer.ensure(appHandlerScope('app-x'), SCRIPT),
-        ];
-        await expect(scheduled).resolves.toBe('busy');
-        await expect(Promise.all(deliveries)).resolves.toEqual([
-            'deployed',
-            'deployed',
-        ]);
-        expect(created).toEqual([SCRIPT]);
-        expect(gated.map((g) => g.capped)).toEqual([true, false]);
-    });
-
-    it('lets a schedule run join a delivery`s deploy in flight', async () => {
-        const { layers, created } = makeLayers({ 'app-x': { ownerUserId: 1 } });
-        const { deployer, gated } = withGate(layers, (capped) => capped);
-
-        const delivery = deployer.ensure(appHandlerScope('app-x'), SCRIPT);
-        const scheduled = deployer.ensure(appHandlerScope('app-x'), SCRIPT, {
-            lane: 'schedule',
-        });
-        await expect(Promise.all([delivery, scheduled])).resolves.toEqual([
-            'deployed',
-            'deployed',
-        ]);
-        expect(gated).toEqual([{ script: SCRIPT, capped: false }]);
-        expect(created).toEqual([SCRIPT]);
-    });
-});
-
-describe('LocalEventsInvokeTransport', () => {
-    it('renders each request as it goes out, after a cold deploy', async () => {
-        const bodies: string[] = [];
-        let resident = false;
-        const transport = new LocalEventsInvokeTransport(
-            {
-                localworkerservice: {
-                    dispatchEventsWorker: async (request: Request) => {
-                        bodies.push(await request.text());
-                        if (!resident) return null;
-                        return new Response(null, {
-                            status: 200,
-                            headers: { 'x-puter-events-handled': '1' },
-                        });
-                    },
-                },
-            } as never,
-            {
-                ensure: async () => {
-                    resident = true;
-                    return 'deployed';
-                },
-                scopeFor: async (appUid: string) => appHandlerScope(appUid),
-            } as unknown as EventsWorkerDeployer,
-        );
-        let renders = 0;
-        const call: EventsInvokeCall = {
-            script: SCRIPT,
-            appUid: 'app-x',
-            key: 'k',
-            body: '{"n":0}',
-            timeoutMs: 5000,
-            render: () => `{"n":${++renders}}`,
-        };
-        await expect(transport.send(call)).resolves.toMatchObject({
-            status: 200,
-        });
-        expect(bodies).toEqual(['{"n":1}', '{"n":2}']);
-    });
-});
-
-describe('deploy-on-miss of an evicted script', () => {
-    it('redeploys the evicted script, then resends the run with the deployed marker', async () => {
-        const { layers, created } = makeLayers({ 'app-m': { ownerUserId: 8 } });
-        // The namespace only has the script once the deploy lands: before
-        // that the dispatcher answers a miss.
-        let resident = false;
-        layers.drivers.workers.create = (async (args: {
-            workerName: string;
-        }) => {
-            created.push(args.workerName);
-            resident = true;
-            return { success: true, errors: [] };
-        }) as never;
-        const deployer = new EventsWorkerDeployer(layers);
-
-        const sent: boolean[] = [];
-        const fetchImpl = (async (_url: string, init?: RequestInit) => {
-            const headers = (init?.headers ?? {}) as Record<string, string>;
-            sent.push(headers[EVENTS_DEPLOYED_HEADER] === '1');
-            if (resident)
-                return new Response(null, {
-                    status: 200,
-                    headers: { [EVENTS_HANDLED_HEADER]: '1' },
-                });
-            return new Response(null, {
-                status: 404,
-                headers: { [EVENTS_DISPATCH_ERROR_HEADER]: 'missing' },
-            });
-        }) as unknown as typeof undiciFetch;
-
-        const client = new EventsWorkerInvokerClient({
-            events: { workerRuntime: true },
-        } as IConfig);
-        client.setTransport(
-            new DispatcherInvokeTransport('http://dispatcher', 's', {
-                fetchImpl,
-            }),
-        );
-        client.setMissHandler((appUid, script, options) =>
-            deployer.ensure(appHandlerScope(appUid), script, options),
-        );
-
-        const result = await client.invoke({
-            script: SCRIPT,
-            appUid: 'app-m',
-            handler: 'h',
-            token: 't',
-            key: 'k',
-            event: {},
-            ctx: {},
-        });
-
-        expect(result).toEqual({ outcome: 'settled', status: 200 });
-        expect(created).toEqual([SCRIPT]);
-        // One miss, then the resend carrying the deployed marker.
-        expect(sent).toEqual([false, true]);
-    });
-});
-
-// The redis mock is shared across tests, so each one uses its own app and code.
-let fresh = 0;
-const nextApp = () => `app-u${++fresh}`;
-const userScope = (holder: number, appUid: string) => ({ appUid, holder });
-const sourceN = (label: string) =>
-    `async () => { await ${label}${++fresh}(); }`;
-const scriptOf = (name: string, source: string) =>
-    userHandlerScript({ name, sourceHash: hashContent(source) }, '');
-
-type Sets = Record<number, Array<{ name: string; source: string }>>;
-
-/** Layers whose handler sets are per holder (0 is the app's own). */
-const withSets = (layers: Layers, sets: Sets) => {
-    const handlersOf = (scope: { appUid: string; holder: number }) =>
-        (sets[scope.holder] ?? []).map((h) => ({
-            appUid: scope.appUid,
-            name: h.name,
-            source: h.source,
-            sourceHash: hashContent(h.source),
-            createdAt: 0,
-            updatedAt: 0,
-        }));
-    const store = layers.stores.eventHandler as unknown as Record<
-        string,
-        unknown
-    >;
-    store.setForApp = async (scope: { appUid: string; holder: number }) =>
-        handlersOf(scope).map(({ name, sourceHash }) => ({ name, sourceHash }));
-    store.allForApp = async (scope: { appUid: string; holder: number }) =>
-        handlersOf(scope);
-};
-
-const holders = (...ids: number[]) =>
-    Object.fromEntries(
-        ids.map((id) => [`holder-${id}`, { ownerUserId: id }]),
-    ) as Record<string, Owner>;
-
-describe('EventsWorkerDeployer in a user scope', () => {
-    it('deploys the one handler whose script was asked for, as the holder', async () => {
-        const app = nextApp();
-        const a = sourceN('a');
-        const b = sourceN('b');
-        const { layers, created, targets } = makeLayers(holders(10));
-        withSets(layers, {
-            10: [
-                { name: 'a', source: a },
-                { name: 'b', source: b },
-            ],
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-
-        const script = scriptOf('b', b);
-        expect(await deployer.ensure(userScope(10, app), script)).toBe(
-            'deployed',
-        );
-
-        expect(created).toEqual([script]);
-        const target = targets[0]!;
-        expect(target.tags).toEqual([`events-app:${app}`, 'user:uuid-10']);
-        // One handler's script: the other one's code is not in it.
-        expect(target.source).toContain(b);
-        expect(target.source).not.toContain(a);
-    });
-
-    it('answers a script no handler of the scope matches as stale, before the throttle', async () => {
-        const app = nextApp();
-        const { layers, redis, created } = makeLayers(holders(10));
-        withSets(layers, { 10: [{ name: 'a', source: sourceN('a') }] });
-        const deployer = new EventsWorkerDeployer(layers);
-
-        expect(
-            await deployer.ensure(
-                userScope(10, app),
-                scriptOf('b', sourceN('b')),
-            ),
-        ).toBe('stale');
-        expect(created).toEqual([]);
-        const hour = new Date().toISOString().slice(0, 13);
-        expect(await redis.get(`ev:deploys:{${app}}:10:${hour}`)).toBeNull();
-    });
-
-    it('answers a scope with no handlers as no-handlers', async () => {
-        const { layers } = makeLayers(holders(10));
-        withSets(layers, {});
-        const deployer = new EventsWorkerDeployer(layers);
-        expect(
-            await deployer.ensure(
-                userScope(10, nextApp()),
-                scriptOf('a', sourceN('a')),
-            ),
-        ).toBe('no-handlers');
-    });
-
-    it('does not deploy for a holder that is suspended or gone', async () => {
-        const source = sourceN('a');
-        const { layers, created } = makeLayers({
-            'holder-10': { ownerUserId: 10, suspended: true },
-        });
-        withSets(layers, {
-            10: [{ name: 'a', source }],
-            11: [{ name: 'a', source }],
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-        const script = scriptOf('a', source);
-        const app = nextApp();
-
-        expect(await deployer.ensure(userScope(10, app), script)).toBe(
-            'no-owner',
-        );
-        expect(await deployer.ensure(userScope(11, app), script)).toBe(
-            'no-owner',
-        );
-        expect(created).toEqual([]);
-    });
-
-    it('gives each scope its own hourly cap, apart from the app scope', async () => {
-        const app = nextApp();
-        const source = sourceN('a');
-        const { layers, created } = makeLayers({
-            ...holders(10, 11),
-            [app]: { ownerUserId: 12 },
-        });
-        withSets(layers, {
-            0: [{ name: 'a', source }],
-            10: [{ name: 'a', source }],
-            11: [{ name: 'a', source }],
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-        const script = scriptOf('a', source);
-
-        for (let i = 0; i < EVENTS_USER_WORKER_DEPLOYS_PER_HOUR; i++)
-            expect(await deployer.ensure(userScope(10, app), script)).toBe(
-                'deployed',
-            );
-        expect(await deployer.ensure(userScope(10, app), script)).toBe(
-            'throttled',
-        );
-        expect(created).toHaveLength(EVENTS_USER_WORKER_DEPLOYS_PER_HOUR);
-
-        // Another holder of the same app, and the app's own scope, still go.
-        expect(await deployer.ensure(userScope(11, app), script)).toBe(
-            'deployed',
-        );
-        expect(await deployer.ensure(appHandlerScope(app), script)).toBe(
-            'deployed',
-        );
-    });
-
-    it('collapses concurrent deploys of one script across holders into one upload', async () => {
-        const app = nextApp();
-        const source = sourceN('a');
-        const { layers, created } = makeLayers(holders(10, 11));
-        withSets(layers, {
-            10: [{ name: 'a', source }],
-            11: [{ name: 'a', source }],
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-        const script = scriptOf('a', source);
-
-        await Promise.all([
-            deployer.ensure(userScope(10, app), script),
-            deployer.ensure(userScope(10, app), script),
-            deployer.ensure(userScope(11, app), script),
-            deployer.ensure(userScope(11, nextApp()), script),
-        ]);
-        expect(created).toHaveLength(1);
-    });
-
-    it('names a script for identical code the same under any holder and app', async () => {
-        const source = sourceN('a');
-        const { layers, created } = makeLayers(holders(10, 11));
-        withSets(layers, {
-            10: [{ name: '@x', source }],
-            11: [{ name: '@x', source }],
-        });
-        const deployer = new EventsWorkerDeployer(layers);
-        const script = scriptOf('@x', source);
-
-        expect(await deployer.ensure(userScope(10, nextApp()), script)).toBe(
-            'deployed',
-        );
-        expect(await deployer.ensure(userScope(11, nextApp()), script)).toBe(
-            'deployed',
-        );
-        expect(created).toEqual([script, script]);
-    });
-});
-
-describe('the deployed marker', () => {
-    const setup = () => {
-        const source = sourceN('a');
-        const made = makeLayers(holders(10, 11));
-        withSets(made.layers, {
-            10: [{ name: 'a', source }],
-            11: [{ name: 'a', source }],
-        });
-        return {
-            ...made,
-            deployer: new EventsWorkerDeployer(made.layers),
-            script: scriptOf('a', source),
-            app: nextApp(),
-        };
-    };
-
-    it('is left by a user-scope deploy with a ttl under a day', async () => {
-        const { deployer, redis, script, app } = setup();
-        await deployer.ensure(userScope(10, app), script);
-        const ttl = await redis.ttl(`ev:deployed:${script}`);
-        expect(ttl).toBeGreaterThan(0);
-        expect(ttl).toBeLessThan(24 * 60 * 60);
-    });
-
-    it('lets an eager deploy skip the upload another holder already made', async () => {
-        const { deployer, created, script, app } = setup();
-        expect(await deployer.deployEagerly(userScope(10, app), script)).toBe(
-            'deployed',
-        );
-        expect(await deployer.deployEagerly(userScope(11, app), script)).toBe(
-            'deployed',
-        );
-        expect(created).toEqual([script]);
-    });
-
-    it('spends no throttle on a skipped eager deploy', async () => {
-        const { deployer, redis, script, app } = setup();
-        await deployer.deployEagerly(userScope(10, app), script);
-        await deployer.deployEagerly(userScope(11, app), script);
-        const hour = new Date().toISOString().slice(0, 13);
-        expect(await redis.get(`ev:deploys:{${app}}:11:${hour}`)).toBeNull();
-    });
-
-    it('never skips a deploy-on-miss', async () => {
-        const { deployer, created, script, app } = setup();
-        await deployer.deployEagerly(userScope(10, app), script);
-        expect(await deployer.ensure(userScope(11, app), script)).toBe(
-            'deployed',
-        );
-        expect(created).toEqual([script, script]);
-    });
-
-    it('is not left by an app-scope deploy', async () => {
-        const app = nextApp();
-        const source = sourceN('a');
-        const { layers, redis, created } = makeLayers({
-            [app]: { ownerUserId: 4 },
-        });
-        withSets(layers, { 0: [{ name: 'a', source }] });
-        const deployer = new EventsWorkerDeployer(layers);
-        const script = scriptOf('a', source);
-        await deployer.ensure(appHandlerScope(app), script);
-        expect(created).toEqual([script]);
-        expect(await redis.get(`ev:deployed:${script}`)).toBeNull();
-    });
-
-    it('still deploys eagerly when the marker cannot be read', async () => {
-        const { deployer, redis, created, script, app } = setup();
-        await deployer.deployEagerly(userScope(10, app), script);
-        const get = redis.get.bind(redis);
-        redis.get = (async (key: string) => {
-            if (key.startsWith('ev:deployed:')) throw new Error('down');
-            return get(key);
-        }) as never;
-        expect(await deployer.deployEagerly(userScope(11, app), script)).toBe(
-            'deployed',
-        );
-        expect(created).toEqual([script, script]);
-    });
-});
-
-describe('scopeFor', () => {
-    it('reads no holder as the app scope, and resolves a uuid to the user scope', async () => {
-        const { layers } = makeLayers(holders(10));
-        const deployer = new EventsWorkerDeployer(layers);
-        expect(await deployer.scopeFor('app-u')).toEqual({
-            appUid: 'app-u',
-            holder: 0,
-        });
-        expect(await deployer.scopeFor('app-u', '')).toEqual({
-            appUid: 'app-u',
-            holder: 0,
-        });
-        expect(await deployer.scopeFor('app-u', 'uuid-10')).toEqual({
-            appUid: 'app-u',
-            holder: 10,
-        });
-        expect(await deployer.scopeFor('app-u', 'uuid-99')).toBeNull();
-    });
-});
-
-describe('LocalEventsInvokeTransport in a user scope', () => {
-    it('deploys the holder`s script on a miss and refuses an unknown holder', async () => {
-        const source = sourceN('a');
-        const { layers, created } = makeLayers(holders(10));
-        withSets(layers, { 10: [{ name: 'a', source }] });
-        const deployer = new EventsWorkerDeployer(layers);
-        let resident = false;
-        const transport = new LocalEventsInvokeTransport(
-            {
-                localworkerservice: {
-                    dispatchEventsWorker: async () => {
-                        if (!resident) return null;
-                        return new Response(null, {
-                            status: 200,
-                            headers: { 'x-puter-events-handled': '1' },
-                        });
-                    },
-                },
-            } as never,
-            {
-                ensure: async (
-                    scope: HandlerScope,
-                    script: string,
-                    options: EventsDeployOptions,
-                ) => {
-                    const outcome = await deployer.ensure(
-                        scope,
-                        script,
-                        options,
-                    );
-                    resident = outcome === 'deployed';
-                    return outcome;
-                },
-                scopeFor: (appUid: string, holder?: string) =>
-                    deployer.scopeFor(appUid, holder),
-            } as unknown as EventsWorkerDeployer,
-        );
-        const script = scriptOf('a', source);
-        const call: EventsInvokeCall = {
-            script,
-            appUid: nextApp(),
-            holder: 'uuid-10',
-            key: 'k',
-            body: '{}',
-            timeoutMs: 5000,
-        };
-
-        await expect(transport.send(call)).resolves.toMatchObject({
-            status: 200,
-        });
-        expect(created).toEqual([script]);
-
-        resident = false;
-        await expect(
-            transport.send({ ...call, holder: 'uuid-99' }),
-        ).resolves.toMatchObject({ status: null, error: 'deploy: no-holder' });
-        expect(created).toEqual([script]);
-    });
-});
-
-describe('concurrent eager deploys of one script', () => {
-    const setup = () => {
-        const source = sourceN('a');
-        const made = makeLayers(holders(10, 11));
-        withSets(made.layers, {
-            10: [{ name: 'a', source }],
-            11: [{ name: 'a', source }],
-        });
-        return {
-            ...made,
-            script: scriptOf('a', source),
-            app: nextApp(),
-        };
-    };
-
-    it('upload once when two holders publish the same new code together', async () => {
-        const { layers, created, script, app } = setup();
-        const deployer = new EventsWorkerDeployer(layers);
-
-        const outcomes = await Promise.all([
-            deployer.deployEagerly(userScope(10, app), script),
-            deployer.deployEagerly(userScope(11, app), script),
-        ]);
-
-        expect(outcomes).toEqual(['deployed', 'deployed']);
-        expect(created).toEqual([script]);
-    });
-
-    it('skip the upload when the marker appears while they wait on the gate', async () => {
-        const { layers, redis, created, script, app } = setup();
-        // Another node's deploy of the script finishes before the gate opens.
-        const gated = new EventsWorkerDeployer({
-            ...layers,
-            services: {
-                schedules: {
-                    gateDeploy: async (
-                        _script: string,
-                        _options: { capped: boolean },
-                        deploy: () => Promise<EventsDeployOutcome>,
-                    ) => {
-                        await redis.set(`ev:deployed:${script}`, '1');
-                        return deploy();
-                    },
-                },
-            },
-        } as unknown as Layers);
-
-        expect(
-            await gated.ensure(userScope(10, app), script, { eager: true }),
-        ).toBe('deployed');
-        expect(created).toEqual([]);
-        // A miss still uploads, whatever the marker says.
-        expect(await gated.ensure(userScope(11, app), script)).toBe('deployed');
-        expect(created).toEqual([script]);
-    });
-
-    it('make a miss that joins an eager deploy deploy after it', async () => {
-        const { layers, redis, created, script, app } = setup();
-        const deployer = new EventsWorkerDeployer(layers);
-        await redis.set(`ev:deployed:${script}`, '1');
-
-        const eager = deployer.ensure(userScope(10, app), script, {
-            eager: true,
-        });
-        const miss = deployer.ensure(userScope(11, app), script);
-
-        expect(await eager).toBe('deployed');
-        expect(await miss).toBe('deployed');
-        // The eager one skipped on the marker; the miss uploaded.
-        expect(created).toEqual([script]);
+        expect(await deployer.ensure('app-d', SCRIPT)).toBe('deployed');
    });
 });
@@ -26,100 +26,50 @@ import {
    INTERNAL_ADMISSION_BYPASS,
    INTERNAL_DEPLOY_TARGET,
 } from '../../drivers/workers/WorkerDriver.js';
-import type {
-    EventsInvokeAnswer,
-    EventsInvokeCall,
-    InvokeLane,
-} from '../../clients/events/EventsWorkerInvokerClient.js';
+import type { EventsInvokeCall } from '../../clients/events/EventsWorkerInvokerClient.js';
 import {
+    EVENTS_HANDLED_HEADER,
    EVENTS_INVOKE_PATH,
-    answerFrom,
-    failedAnswer,
 } from '../../clients/events/EventsWorkerInvokerClient.js';
 import type { puterServices } from '../../services/index.js';
-import type { IExtensionServiceInstances } from '../../services/types.js';
 import {
    eventsInvokeKey,
    eventsWorkerScope,
    eventsWorkerScript,
-    userHandlerScript,
 } from '../../services/events/workerRuntime.js';
-import {
-    generateEventsWorkerSource,
-    handlerSetHash,
-} from '../../services/events/workerSource.js';
-import {
-    appHandlerScope,
-    type HandlerScope,
-} from '../../stores/events/EventHandlerStore.js';
+import { generateEventsWorkerSource } from '../../services/events/workerSource.js';
 import type { puterStores } from '../../stores/index.js';
 import type { IConfig, LayerInstances } from '../../types.js';
-import {
-    EVENTS_USER_WORKER_DEPLOYS_PER_HOUR,
-    EVENTS_WORKER_DEPLOYS_PER_HOUR,
-} from './limits.js';
+import { EVENTS_WORKER_DEPLOYS_PER_HOUR } from './limits.js';

 /**
 * Deploys an app's events worker from its published handlers.
 *
 * Deployed the first time a delivery needs it and again on eviction — a publish
- * only writes rows (a user-scope publish also deploys eagerly). An app's scope
- * is one script for the whole set; a user scope is one script per handler,
- * deployed as the holder. Scripts carry no worker token and no `subdomains`
- * row: not one of the owner's workers, not addressable from the internet, not
- * listed or deleted as if it were. A republished set leaves the old script
- * behind rather than deleting it; redeploying a still-live one is always safe.
+ * only writes rows. Scripts carry no worker token and no `subdomains` row: not
+ * one of the owner's workers, not addressable from the internet, not listed or
+ * deleted as if it were. A republished set leaves the old script behind rather
+ * than deleting it; redeploying a still-live one is always safe.
 */

 /** Why a deploy could not happen, for the callers that answer differently. */
 export type EventsDeployOutcome =
-    | 'deployed'
-    | 'stale'
-    | 'no-handlers'
-    | 'no-owner'
-    | 'throttled'
-    | 'failed'
-    | 'busy';
-
-/** Whose call asked for the deploy: a schedule run's is held to a share. */
-export interface EventsDeployOptions {
-    lane?: InvokeLane;
-    /**
-     * A user-scope publish's deploy, which skips the upload when the script's
-     * deployed marker is already set. A deploy-on-miss is never eager.
-     */
-    eager?: boolean;
-}
+    'deployed' | 'stale' | 'no-handlers' | 'no-owner' | 'throttled' | 'failed';

 interface DeployLayers {
    config: IConfig;
    clients: LayerInstances<typeof puterClients>;
    stores: LayerInstances<typeof puterStores>;
-    services: LayerInstances<typeof puterServices> &
-        Pick<IExtensionServiceInstances, 'schedules'>;
+    services: LayerInstances<typeof puterServices>;
    drivers: LayerInstances<typeof puterDrivers>;
 }

 /**
- * `ev:deploys:{<appUid>}[:<holder>]:<hour>` bucket TTL — comfortably past the
- * hour it counts.
+ * `ev:deploys:{<appUid>}:<hour>` bucket TTL — comfortably past the hour it
+ * counts.
 */
 const DEPLOY_THROTTLE_TTL_SECONDS = 2 * 60 * 60;

-/** How long `ev:deployed:<script>` says a script was uploaded. Under a day. */
-const DEPLOYED_MARKER_TTL_SECONDS = 20 * 60 * 60;
-
-const deployedMarkerKey = (script: string): string => `ev:deployed:${script}`;
-
-const isUserScope = (scope: HandlerScope): boolean => scope.holder !== 0;
-
-interface InFlightDeploy {
-    /** A schedule run's, which the region's deploy slots may refuse. */
-    capped: boolean;
-    eager: boolean;
-    promise: Promise<EventsDeployOutcome>;
-}
-
 interface DeployResult {
    success?: boolean;
    errors?: unknown[];
@@ -128,7 +78,7 @@ interface DeployResult {
 export class EventsWorkerDeployer {
    readonly #layers: DeployLayers;
    /** Collapses the burst of misses one cold app produces into one deploy. */
-    readonly #inFlight = new Map<string, InFlightDeploy>();
+    readonly #inFlight = new Map<string, Promise<EventsDeployOutcome>>();

    constructor(layers: DeployLayers) {
        this.#layers = layers;
@@ -143,187 +93,39 @@ export class EventsWorkerDeployer {
    }

    /**
-     * Deploy `script`, which must be what the scope's handlers currently hash
-     * to: the whole set for an app, one handler for a user scope. A request for
-     * anything else is `stale` — the handlers moved on, and the next delivery
-     * resolves the new script rather than this one being revived. Always
-     * uploads; a deploy-on-miss means whatever said it was there is wrong.
+     * Deploy `script`, which must be what the app's handlers currently hash to.
+     * A request for anything else is `stale` — the set moved on, and the next
+     * delivery resolves the new script rather than this one being revived.
     */
-    ensure(
-        scope: HandlerScope,
-        script: string,
-        options: EventsDeployOptions = {},
-    ): Promise<EventsDeployOutcome> {
-        // A user scope's script is the same bytes whoever holds it, so
-        // concurrent deploys of it from any holder or app are one.
-        const key = isUserScope(scope)
-            ? `user|${script}`
-            : `${scope.appUid}|${scope.holder}|${script}`;
-        const capped = options.lane === 'schedule';
+    ensure(appUid: string, script: string): Promise<EventsDeployOutcome> {
+        const key = `${appUid}|${script}`;
        const existing = this.#inFlight.get(key);
-        if (!existing) return this.#start(key, scope, script, options);
-        // An eager deploy may have skipped the upload, which a miss must not
-        // take for done.
-        if (existing.eager && !options.eager)
-            return this.#afterEager(
-                existing.promise,
-                key,
-                scope,
-                script,
-                options,
-            );
-        if (capped || !existing.capped) return existing.promise;
-        return this.#afterCapped(existing.promise, key, scope, script, options);
-    }
-
-    /**
-     * {@link ensure} for the deploy a user-scope publish starts, which skips the
-     * upload when another holder's deploy of the same script left its marker.
-     * Only this path reads the marker.
-     */
-    async deployEagerly(
-        scope: HandlerScope,
-        script: string,
-    ): Promise<EventsDeployOutcome> {
-        if (await this.#markedDeployed(script)) return 'deployed';
-        return this.ensure(scope, script, { eager: true });
-    }
-
-    /**
-     * The scope a script request names: the app's own, or the user scope of
-     * `holder` (a user uuid). Null for a holder that does not exist.
-     */
-    async scopeFor(
-        appUid: string,
-        holder?: string | null,
-    ): Promise<HandlerScope | null> {
-        if (!holder) return appHandlerScope(appUid);
-        const user = await this.#layers.stores.user.getByUuid(holder);
-        if (!user?.id) return null;
-        return { appUid, holder: Number(user.id) };
-    }
-
-    #start(
-        key: string,
-        scope: HandlerScope,
-        script: string,
-        options: EventsDeployOptions,
-    ): Promise<EventsDeployOutcome> {
-        const entry: InFlightDeploy = {
-            capped: options.lane === 'schedule',
-            eager: options.eager === true,
-            promise: this.#gated(scope, script, options).finally(() => {
-                if (this.#inFlight.get(key) === entry)
-                    this.#inFlight.delete(key);
-            }),
-        };
-        this.#inFlight.set(key, entry);
-        return entry.promise;
-    }
-
-    /** A miss that found an eager deploy in flight deploys after it. */
-    async #afterEager(
-        eager: Promise<EventsDeployOutcome>,
-        key: string,
-        scope: HandlerScope,
-        script: string,
-        options: EventsDeployOptions,
-    ): Promise<EventsDeployOutcome> {
-        await eager;
-        const current = this.#inFlight.get(key);
-        if (current && !current.eager) return current.promise;
-        return this.#start(key, scope, script, options);
-    }
-
-    /**
-     * A delivery that joined a schedule run's deploy: `busy` means no deploy
-     * started, and a delivery is never refused a slot, so it asks again.
-     */
-    async #afterCapped(
-        capped: Promise<EventsDeployOutcome>,
-        key: string,
-        scope: HandlerScope,
-        script: string,
-        options: EventsDeployOptions,
-    ): Promise<EventsDeployOutcome> {
-        const outcome = await capped;
-        if (outcome !== 'busy') return outcome;
-        const current = this.#inFlight.get(key);
-        if (current && !current.capped) return current.promise;
-        return this.#start(key, scope, script, options);
-    }
-
-    /**
-     * Every deploy goes through the schedules' deploy gate when a server has
-     * one: a per-script lock, so a burst of runs of an evicted script deploys
-     * it once, and a region-wide cap that a schedule run's deploy (`capped`)
-     * may be refused with `busy`. A delivery's deploy is never refused.
-     */
-    #gated(
-        scope: HandlerScope,
-        script: string,
-        options: EventsDeployOptions,
-    ): Promise<EventsDeployOutcome> {
-        const deploy = () =>
-            this.#deploy(scope, script, options.eager === true);
-        return (
-            this.#layers.services.schedules?.gateDeploy?.(
-                script,
-                { capped: options.lane === 'schedule' },
-                deploy,
-            ) ?? deploy()
+        if (existing) return existing;
+        const started = this.#deploy(appUid, script).finally(() =>
+            this.#inFlight.delete(key),
        );
+        this.#inFlight.set(key, started);
+        return started;
    }

    async #deploy(
-        handlerScope: HandlerScope,
+        appUid: string,
        script: string,
-        eager: boolean,
    ): Promise<EventsDeployOutcome> {
-        const { appUid } = handlerScope;
        const { stores, drivers } = this.#layers;
-        const backend = eventsWorkerScope(this.#layers.config);
-        const userScope = isUserScope(handlerScope);

-        // Names and hashes are enough to tell a stale request, so the set's
-        // sources are read and built only once the throttle has let it through.
-        const set = await stores.eventHandler.setForApp(handlerScope);
-        if (set.length === 0) return 'no-handlers';
+        const handlers = await stores.eventHandler.allForApp(appUid);
+        if (handlers.length === 0) return 'no-handlers';
+
+        const generated = generateEventsWorkerSource(handlers);
        // Two apps that published byte-identical sets share one script, which
        // is sound: the source is the same, and everything per-app arrives with
-        // the invocation. Whoever deploys first owns it. A user scope's script
-        // is one handler's, so it is shared the same way across holders.
-        const wanted = userScope
-            ? set.find((entry) => userHandlerScript(entry, backend) === script)
-            : undefined;
+        // the invocation. Whoever deploys first owns it.
        if (
-            userScope
-                ? !wanted
-                : eventsWorkerScript(handlerSetHash(set), backend) !== script
-        )
-            return 'stale';
-
-        // Asked again inside the gate, where another deploy of this script may
-        // have just finished.
-        if (eager && userScope && (await this.#markedDeployed(script)))
-            return 'deployed';
-
-        if (await this.#tooManyDeploysThisHour(handlerScope))
-            return 'throttled';
-
-        const all = await stores.eventHandler.allForApp(handlerScope);
-        const handlers = wanted
-            ? all.filter(
-                  (handler) =>
-                      handler.name === wanted.name &&
-                      handler.sourceHash === wanted.sourceHash,
-              )
-            : all;
-        const generated = generateEventsWorkerSource(handlers);
-        // The set can move between the two reads.
-        if (
-            handlers.length === 0 ||
-            eventsWorkerScript(generated.setHash, backend) !== script
+            eventsWorkerScript(
+                generated.setHash,
+                eventsWorkerScope(this.#layers.config),
+            ) !== script
        )
            return 'stale';
        if (generated.tooLarge) {
@@ -338,7 +140,9 @@ export class EventsWorkerDeployer {
                generated.broken.join(', '),
            );

-        const owner = await this.#owner(handlerScope);
+        if (await this.#tooManyDeploysThisHour(appUid)) return 'throttled';
+
+        const owner = await this.#owner(appUid);
        if (!owner) return 'no-owner';

        const secret = this.#layers.config.events?.internalSecret;
@@ -367,7 +171,6 @@ export class EventsWorkerDeployer {
                        runtime: 'events',
                        source: generated.source,
                        omitOwnerToken: true,
-                        cpuMs: this.#layers.config.events?.workerCpuMs,
                        // What the script compares an invocation against.
                        // Derived from the script name, so a redeploy of
                        // the same set binds the same key.
@@ -398,74 +201,34 @@ export class EventsWorkerDeployer {
            );
            return 'failed';
        }
-        if (userScope) await this.#markDeployed(script);
        return 'deployed';
    }

-    async #markedDeployed(script: string): Promise<boolean> {
-        try {
-            return !!(await this.#layers.clients.redis.get(
-                deployedMarkerKey(script),
-            ));
-        } catch (err) {
-            console.warn('[events] deployed marker unreadable', err);
-            return false;
-        }
-    }
-
-    async #markDeployed(script: string): Promise<void> {
-        try {
-            await this.#layers.clients.redis.set(
-                deployedMarkerKey(script),
-                '1',
-                'EX',
-                DEPLOYED_MARKER_TTL_SECONDS,
-            );
-        } catch (err) {
-            console.warn('[events] could not mark a script deployed', err);
-        }
-    }
-
    /**
-     * Whether this scope has already deployed its hourly cap this hour. A
-     * flapping set (publish, remove, republish) provisions upstream on every
-     * miss, and this is the ceiling on that loop. An app's counter is per app;
-     * a user scope has its own, so one user cannot spend another's.
+     * Whether this app has already deployed `EVENTS_WORKER_DEPLOYS_PER_HOUR`
+     * times this hour. A flapping set (publish, remove, republish) provisions
+     * upstream on every miss, and this is the ceiling on that loop.
     */
-    async #tooManyDeploysThisHour(scope: HandlerScope): Promise<boolean> {
+    async #tooManyDeploysThisHour(appUid: string): Promise<boolean> {
        const redis = this.#layers.clients.redis;
        const hour = new Date().toISOString().slice(0, 13);
-        const userScope = isUserScope(scope);
-        const key = userScope
-            ? `ev:deploys:{${scope.appUid}}:${scope.holder}:${hour}`
-            : `ev:deploys:{${scope.appUid}}:${hour}`;
+        const key = `ev:deploys:{${appUid}}:${hour}`;
        const count = await redis.incr(key);
        if (count === 1) await redis.expire(key, DEPLOY_THROTTLE_TTL_SECONDS);
-        return (
-            count >
-            (userScope
-                ? EVENTS_USER_WORKER_DEPLOYS_PER_HOUR
-                : EVENTS_WORKER_DEPLOYS_PER_HOUR)
-        );
+        return count > EVENTS_WORKER_DEPLOYS_PER_HOUR;
    }

-    /**
-     * The user a scope's deploy runs as, as an actor: the app's owner, or the
-     * holder of a user scope.
-     */
+    /** The app owner, as an actor the deploy can run as. */
    async #owner(
-        scope: HandlerScope,
+        appUid: string,
    ): Promise<
        | (Actor & { user: { id: number; uuid: string; username: string } })
        | null
    > {
        const { stores } = this.#layers;
-        let ownerUserId = scope.holder;
-        if (!isUserScope(scope)) {
-            const app = await stores.app.getByUid(scope.appUid);
-            ownerUserId = Number(app?.owner_user_id);
-            if (!app || !Number.isFinite(ownerUserId)) return null;
-        }
+        const app = await stores.app.getByUid(appUid);
+        const ownerUserId = Number(app?.owner_user_id);
+        if (!app || !Number.isFinite(ownerUserId)) return null;

        const user = await stores.user.getById(ownerUserId);
        if (!user?.id || !user.uuid || !user.username || user.suspended)
@@ -526,9 +289,11 @@ export class LocalEventsInvokeTransport {
        this.#deployer = deployer;
    }

-    async send(call: EventsInvokeCall): Promise<EventsInvokeAnswer> {
-        // Built per attempt, so a send time stamped into the body is taken
-        // after a cold deploy rather than before it.
+    async send(call: EventsInvokeCall): Promise<{
+        status: number | null;
+        handled?: boolean;
+        error?: string;
+    }> {
        const request = (): Request =>
            new Request(
                `http://${call.script}.workers.puter.localhost${EVENTS_INVOKE_PATH}`,
@@ -538,7 +303,7 @@ export class LocalEventsInvokeTransport {
                        'content-type': 'application/json',
                        'x-puter-events-key': call.key,
                    },
-                    body: call.render ? call.render() : call.body,
+                    body: call.body,
                },
            );

@@ -546,27 +311,22 @@ export class LocalEventsInvokeTransport {
            const resident = await this.#dispatch(request(), call.timeoutMs);
            if (resident !== null) return resident;

-            const scope = await this.#deployer.scopeFor(
+            const outcome = await this.#deployer.ensure(
                call.appUid,
-                call.holder,
+                call.script,
            );
-            if (!scope) return { status: null, error: 'deploy: no-holder' };
-            const outcome = await this.#deployer.ensure(scope, call.script, {
-                lane: call.lane,
-            });
            if (outcome !== 'deployed')
-                return {
-                    status: null,
-                    error: `deploy: ${outcome}`,
-                    ...(outcome === 'busy' ? { deployBusy: true } : {}),
-                };
+                return { status: null, error: `deploy: ${outcome}` };

            const retried = await this.#dispatch(request(), call.timeoutMs);
            if (retried === null)
                return { status: null, error: 'script not resident' };
            return retried;
        } catch (err) {
-            return failedAnswer(err);
+            return {
+                status: null,
+                error: err instanceof Error ? err.message : String(err),
+            };
        }
    }

@@ -577,7 +337,7 @@ export class LocalEventsInvokeTransport {
    async #dispatch(
        request: Request,
        timeoutMs: number,
-    ): Promise<EventsInvokeAnswer | null> {
+    ): Promise<{ status: number; handled: boolean } | null> {
        let timer: ReturnType<typeof setTimeout> | undefined;
        const timeout = new Promise<'timeout'>((resolve) => {
            timer = setTimeout(() => resolve('timeout'), timeoutMs);
@@ -588,10 +348,12 @@ export class LocalEventsInvokeTransport {
                this.#services.localworkerservice.dispatchEventsWorker(request),
                timeout,
            ]);
-            if (response === 'timeout')
-                throw new DOMException('invocation timed out', 'TimeoutError');
+            if (response === 'timeout') throw new Error('invocation timed out');
            if (response === null) return null;
-            return answerFrom(response);
+            return {
+                status: response.status,
+                handled: response.headers.get(EVENTS_HANDLED_HEADER) === '1',
+            };
        } finally {
            clearTimeout(timer);
        }
@@ -27,7 +27,6 @@ import type { Actor } from '../../core/actor.js';
 import { PuterRouter } from '../../core/http/PuterRouter.js';
 import { PuterServer } from '../../server.js';
 import { setupTestServer } from '../../testUtil.js';
-import { embedFrameAncestors, embedHostOrigin } from './HomepageController.js';

 // ── Test harness ────────────────────────────────────────────────────
 //
@@ -530,46 +529,3 @@ describe('HomepageController GET /sw.js', () => {
        expect(route?.options.subdomain).toBe('');
    });
 });
-
-describe('embedFrameAncestors', () => {
-    const config = {
-        origin: 'https://example.test',
-        domain: 'example.test',
-        api_base_url: 'https://backend.example.test',
-    };
-
-    it('names a sibling subdomain that embeds the browser', () => {
-        expect(
-            embedFrameAncestors(config, 'https://sheets.example.test/doc/1'),
-        ).toBe("'self' https://sheets.example.test");
-    });
-
-    it('refuses the configured API host even off the api label', () => {
-        expect(
-            embedFrameAncestors(config, 'https://backend.example.test/x'),
-        ).toBe("'self'");
-    });
-});
-
-describe('embedHostOrigin', () => {
-    const config = {
-        origin: 'https://example.test',
-        domain: 'example.test',
-        api_base_url: 'https://backend.example.test',
-        static_hosting_domain: 'site.example.test',
-    };
-
-    it.each([
-        ['https://sheets.example.test/doc/1', 'https://sheets.example.test'],
-        ['https://backend.example.test/x', null],
-        ['https://api.example.test/', null],
-        ['https://someone.site.example.test/', null],
-        ['https://a.sheets.example.test/', null],
-        ['http://sheets.example.test/', null],
-        ['https://example.test/', null],
-        ['not a url', null],
-        [undefined, null],
-    ])('%s frames as %s', (referer, expected) => {
-        expect(embedHostOrigin(config, referer)).toBe(expected);
-    });
-});
@@ -22,11 +22,6 @@ import path from 'node:path';
 import { PuterController } from '../types.js';
 import { toAppShellView } from '../../util/appShellView.js';
 import type { PuterRouter } from '../../core/http/PuterRouter';
-import {
-    isReservedSubdomain,
-    subdomainLabelOf,
-} from '../../core/http/middleware/hostRedirects.js';
-import type { IConfig } from '../../types';
 import type {
    PuterHomepageService,
    PageMeta,
@@ -48,9 +43,9 @@ const APP_LANDING_LIMIT = {
 };

 /**
- * App descriptions can run long; search snippets and social cards want a short
- * blurb. Collapses whitespace, then cuts at a word boundary with an ellipsis so
- * the result never exceeds `APP_META_DESCRIPTION_MAX`.
+ * App descriptions can run long; search snippets and social cards want a
+ * short blurb. Collapses whitespace, then cuts at a word boundary with an
+ * ellipsis so the result never exceeds `APP_META_DESCRIPTION_MAX`.
 */
 export function appMetaDescription(text: string): string {
    const clean = text.replace(/\s+/g, ' ').trim();
@@ -61,64 +56,6 @@ export function appMetaDescription(text: string): string {
    return `${cut.replace(/[\s,;:.!?…—-]+$/, '')}…`;
 }

-type EmbedFramingConfig = Pick<
-    IConfig,
-    | 'origin'
-    | 'domain'
-    | 'api_base_url'
-    | 'static_hosting_domain'
-    | 'static_hosting_domain_alt'
-    | 'private_app_hosting_domain'
-    | 'private_app_hosting_domain_alt'
->;
-
-/**
- * The origin of a first-party page that may frame an `/embed/*` page, named
- * exactly from the request's referrer, or null. A wildcard over `*.<domain>`
- * would also admit user-hosted sites whenever the hosting domains sit under it,
- * so only a single label under `<domain>` qualifies, and not one this server
- * answers itself (the API, WebDAV, SDK and native-app hosts).
- */
-export function embedHostOrigin(
-    config: EmbedFramingConfig,
-    referer: string | undefined,
-): string | null {
-    const gui = new URL(config.origin ?? `https://${config.domain}`);
-    let parent: URL;
-    try {
-        parent = new URL(referer ?? '');
-    } catch {
-        return null;
-    }
-    const host = parent.hostname.toLowerCase();
-    const label = subdomainLabelOf(host, config.domain);
-    const hostingDomains = [
-        config.static_hosting_domain,
-        config.static_hosting_domain_alt,
-        config.private_app_hosting_domain,
-        config.private_app_hosting_domain_alt,
-    ]
-        .map((d) => (d ?? '').toLowerCase().split(':')[0])
-        .filter(Boolean);
-    const allowed =
-        parent.protocol === gui.protocol &&
-        parent.port === gui.port &&
-        label !== undefined &&
-        !isReservedSubdomain(label) &&
-        host !== new URL(config.api_base_url).hostname &&
-        !hostingDomains.some((d) => host === d || host.endsWith(`.${d}`));
-    return allowed ? parent.origin : null;
-}
-
-/** `frame-ancestors` for an `/embed/*` page: the GUI and {@link embedHostOrigin}. */
-export function embedFrameAncestors(
-    config: EmbedFramingConfig,
-    referer: string | undefined,
-): string {
-    const host = embedHostOrigin(config, referer);
-    return host ? `'self' ${host}` : "'self'";
-}
-
 /**
 * Routes that render the Puter GUI shell, plus a catch-all static fallback
 * under `<gui_assets_root>/src` for non-dist/src paths (images, fonts, lib
@@ -168,54 +105,6 @@ export class HomepageController extends PuterController {

        router.get('/', {}, (req, res) => sendShell(req, res));

-        /**
-         * Headers shared by the `/embed/*` pages; false when the request was
-         * redirected instead. SDK bootstrap parameters must not change an
-         * embed's account or API origin, so a query string is dropped. Checked
-         * on the raw URL; `req.query` drops pairs past the parser's limit.
-         */
-        const prepareEmbed = (
-            req: express.Request,
-            res: express.Response,
-            path: string,
-        ): boolean => {
-            if (req.originalUrl.includes('?')) {
-                res.redirect(path);
-                return false;
-            }
-            res.removeHeader('X-Frame-Options');
-            res.setHeader(
-                'Content-Security-Policy',
-                `frame-ancestors ${embedFrameAncestors(this.config, req.get('referer'))}`,
-            );
-            res.setHeader('Cache-Control', 'no-store');
-            return true;
-        };
-
-        router.get('/embed/apps', {}, async (req, res) => {
-            if (!prepareEmbed(req, res, '/embed/apps')) return;
-            // Shown to visitors without a session; a signed-in embed fetches
-            // its own list, so a failure here only costs signed-out visitors.
-            const guestApps = await this.services.recommendedApps
-                .getRecommendedApps()
-                .catch((): Array<Record<string, unknown>> => []);
-            res.send(homepage.renderAppBrowserEmbed({ guestApps }));
-        });
-
-        router.get('/embed/feedback', {}, (req, res) => {
-            if (!prepareEmbed(req, res, '/embed/feedback')) return;
-            // The feedback is recorded against this origin, which
-            // frame-ancestors has just pinned to the actual framing page.
-            res.send(
-                homepage.renderFeedbackEmbed({
-                    hostOrigin: embedHostOrigin(
-                        this.config,
-                        req.get('referer'),
-                    ),
-                }),
-            );
-        });
-
        router.get('/settings', {}, (req, res) => sendShell(req, res));
        router.get('/settings/*splat', {}, (req, res) => sendShell(req, res));

@@ -42,7 +42,6 @@ import {
    EVENTS_KV_HANDLES_PER_USER,
    KV_SHARE_BATCH_MAX,
    KV_SHARE_GRANT_LIMITS,
-    KV_SHARE_LOOKUP_LIMIT,
 } from '../events/limits.js';

 const BOOT_TIMEOUT_MS = 120_000;
@@ -68,7 +67,6 @@ const resetBudgets = async (env: PuterTestEnv) => {
        const user = await env.server.stores.user.getByUsername(name);
        for (const scope of [
            EVENTS_KV_HANDLE_LIMIT.scope,
-            KV_SHARE_LOOKUP_LIMIT.scope,
            ...KV_SHARE_GRANT_LIMITS.map((window) => window.scope),
        ])
            await env.server.clients.redis.del(`rate:${scope}:${user!.id}`);
@@ -125,7 +123,6 @@ describe('/kv/shares', () => {
                'handle',
                'holder',
                'label',
-                'notify',
                'prefix',
            ].sort(),
        );
@@ -134,42 +131,6 @@ describe('/kv/shares', () => {
            appUid: null,
            holder: env.users.other.username,
            label: 'Groceries',
-            notify: false,
-        });
-    });
-
-    it('takes notify, keeps it on a re-share that leaves it out, and shows it to both sides', async () => {
-        const prefix = `notify-${uuidv4().slice(0, 8)}:`;
-        const on = await shareWithOther({ prefix, notify: true });
-        expect(on).toMatchObject({ prefix, notify: true });
-
-        const kept = await shareWithOther({ prefix, access: 'write' });
-        expect(kept).toMatchObject({ handle: on.handle, notify: true });
-
-        const listed = async (path: string, token: string) =>
-            (
-                (await (await req('GET', path, token)).json()) as {
-                    items: Array<Record<string, unknown>>;
-                }
-            ).items.find((row) => row.handle === on.handle);
-        expect(
-            await listed('/kv/shares?limit=200', env.users.user.token),
-        ).toMatchObject({ notify: true });
-        expect(
-            await listed('/kv/shares/with-me?limit=200', env.users.other.token),
-        ).toMatchObject({ notify: true });
-
-        const off = await shareWithOther({ prefix, notify: false });
-        expect(off).toMatchObject({ handle: on.handle, notify: false });
-
-        const refused = await req('POST', '/kv/shares', env.users.user.token, {
-            prefix,
-            recipient: env.users.other.username,
-            notify: 'yes',
-        });
-        expect(refused.status).toBe(400);
-        await expect(refused.json()).resolves.toMatchObject({
-            code: 'kv_share_notify_invalid',
        });
    });

@@ -208,7 +169,6 @@ describe('/kv/shares', () => {
            appUid: null,
            holder: env.users.other.username,
            label: 'Trip',
-            notify: false,
            createdAt: shared.createdAt,
            revokedAt: null,
            revokedBy: null,
@@ -230,7 +190,6 @@ describe('/kv/shares', () => {
            access: 'write',
            appUid: null,
            label: 'Trip',
-            notify: false,
            createdAt: shared.createdAt,
        });
        expect(withMeText).not.toContain(env.users.user.username);
@@ -663,162 +622,6 @@ describe('/kv/shares', () => {
            }
        });
    });
-
-    describe('sharing again', () => {
-        let ownerId: number;
-        let third: string;
-
-        beforeAll(async () => {
-            third = `kv-again-${uuidv4().slice(0, 8)}`;
-            await createTestUser(env.server, {
-                username: third,
-                password: 'pw-test-1234',
-            });
-            ownerId = (await env.server.stores.user.getByUsername(
-                env.users.user.username,
-            ))!.id!;
-        });
-
-        const shareAt = (prefix: string, body: Record<string, unknown>) =>
-            req('POST', '/kv/shares', env.users.user.token, {
-                prefix,
-                ...body,
-            });
-
-        /** Leaves `left` units in one of the owner's windows. */
-        const drain = (
-            window: { scope: string; limit: number; window: number },
-            left = 0,
-        ) =>
-            claimRateLimit(
-                `${window.scope}:${ownerId}`,
-                window.limit,
-                window.window,
-                window.limit - left,
-            );
-
-        it('spends neither the mint nor the grant budget when every share stays as it is', async () => {
-            const prefix = `again-${uuidv4().slice(0, 8)}:`;
-            const recipients = [env.users.other.username, third];
-            const made = (await (
-                await shareAt(prefix, { recipients, label: 'Room' })
-            ).json()) as { items: Array<{ handle: string }> };
-            await drain(EVENTS_KV_HANDLE_LIMIT);
-            for (const window of KV_SHARE_GRANT_LIMITS) await drain(window);
-            try {
-                const again = await shareAt(prefix, {
-                    recipients: [...recipients, third],
-                });
-                expect(again.status).toBe(200);
-                const { items } = (await again.json()) as {
-                    items: Array<{ handle: string; label: string }>;
-                };
-                expect(items.map((item) => item.handle)).toEqual([
-                    made.items[0].handle,
-                    made.items[1].handle,
-                    made.items[1].handle,
-                ]);
-                expect(items[0].label).toBe('Room');
-
-                const single = await shareAt(prefix, {
-                    recipient: env.users.other.username,
-                    access: 'read',
-                });
-                expect(single.status).toBe(200);
-            } finally {
-                await resetBudgets(env);
-            }
-        });
-
-        it('spends the mint budget on a change, and grant units only on recipients without the share', async () => {
-            const prefix = `again-${uuidv4().slice(0, 8)}:`;
-            const other = env.users.other.username;
-            expect((await shareAt(prefix, { recipient: other })).status).toBe(
-                200,
-            );
-            for (const window of KV_SHARE_GRANT_LIMITS) await drain(window);
-            try {
-                // A level change on a standing share takes no grant unit.
-                const raised = await shareAt(prefix, {
-                    recipients: [other],
-                    access: 'write',
-                });
-                expect(raised.status).toBe(200);
-
-                // Naming an unknown user next to it costs what a new share
-                // would, so the window refuses both.
-                for (const extra of ['nobody-by-this-name', third]) {
-                    const refused = await shareAt(prefix, {
-                        recipients: [other, extra],
-                        access: 'write',
-                    });
-                    expect(refused.status).toBe(429);
-                }
-            } finally {
-                await resetBudgets(env);
-            }
-
-            await drain(EVENTS_KV_HANDLE_LIMIT);
-            try {
-                const lowered = await shareAt(prefix, {
-                    recipient: other,
-                    access: 'read',
-                });
-                expect(lowered.status).toBe(429);
-                await expect(lowered.json()).resolves.toMatchObject({
-                    code: 'too_many_requests',
-                });
-            } finally {
-                await resetBudgets(env);
-            }
-        });
-
-        it('counts turning notify on or off as a change', async () => {
-            const prefix = `again-${uuidv4().slice(0, 8)}:`;
-            const other = env.users.other.username;
-            expect((await shareAt(prefix, { recipient: other })).status).toBe(
-                200,
-            );
-            await drain(EVENTS_KV_HANDLE_LIMIT);
-            try {
-                expect(
-                    (await shareAt(prefix, { recipient: other })).status,
-                ).toBe(200);
-                expect(
-                    (
-                        await shareAt(prefix, {
-                            recipient: other,
-                            notify: true,
-                        })
-                    ).status,
-                ).toBe(429);
-            } finally {
-                await resetBudgets(env);
-            }
-        });
-
-        it('spends the lookup budget on every recipient named', async () => {
-            const prefix = `again-${uuidv4().slice(0, 8)}:`;
-            const other = env.users.other.username;
-            expect((await shareAt(prefix, { recipient: other })).status).toBe(
-                200,
-            );
-            await resetBudgets(env);
-            await drain(KV_SHARE_LOOKUP_LIMIT, 1);
-            try {
-                expect(
-                    (await shareAt(prefix, { recipient: other })).status,
-                ).toBe(200);
-                const refused = await shareAt(prefix, { recipient: other });
-                expect(refused.status).toBe(429);
-                await expect(refused.json()).resolves.toMatchObject({
-                    code: 'too_many_requests',
-                });
-            } finally {
-                await resetBudgets(env);
-            }
-        });
-    });
 });

 describe('/events/kv-handles beside /kv/shares', () => {
@@ -69,7 +69,6 @@ const shareBody = (share: KvShareView) => ({
    appUid: publicAppUid(share.appUid),
    holder: share.holderUsername,
    label: share.label,
-    notify: share.notify,
    createdAt: share.createdAt,
 });

@@ -129,8 +128,8 @@ export class KvShareController extends PuterController {
    /**
     * POST /kv/shares — share a region with another account, `read` unless the
     * body asks otherwise. Sharing the same region with the same account again
-     * changes its level, label or `notify` flag in place. `recipients` shares
-     * it with several at once and reports each one on its own item.
+     * changes its level or label in place. `recipients` shares it with several
+     * at once and reports each one on its own item.
     */
    @Post('/shares', {
        subdomain: 'api',
@@ -146,7 +145,6 @@ export class KvShareController extends PuterController {
            access: body.access,
            appUid: body.appUid,
            label: body.label,
-            notify: body.notify,
        };
        const recipients = batchRecipients(body);
        if (recipients) {
@@ -208,7 +206,6 @@ export class KvShareController extends PuterController {
                appUid: publicAppUid(row.appUid),
                holder: row.holderUsername,
                label: row.label,
-                notify: row.notify,
                createdAt: row.createdAt,
                revokedAt: row.revokedAt,
                revokedBy: row.revokedBy,
@@ -237,7 +234,6 @@ export class KvShareController extends PuterController {
                access: row.access,
                appUid: publicAppUid(row.appUid),
                label: row.label,
-                notify: row.notify,
                createdAt: row.createdAt,
            })),
            ...(page.cursor ? { cursor: page.cursor } : {}),
@@ -21,9 +21,9 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { setupPuterTestEnv, type PuterTestEnv } from '../../testUtil.js';

 /**
- * Route-level coverage for the notification endpoints the desktop calls over
- * HTTP, so this suite is what catches a route going missing or a gate turning
- * a legitimate dismiss or removal away.
+ * Route-level coverage for the notification endpoint. Dismissing is the only
+ * mark the desktop performs over HTTP, so this suite is what catches the route
+ * going missing or a gate turning a legitimate dismiss away.
 */
 describe('notification endpoints over HTTP', () => {
    let env: PuterTestEnv;
@@ -85,34 +85,4 @@ describe('notification endpoints over HTTP', () => {
        });
        expect(after?.acknowledged).toBeFalsy();
    });
-
-    it('removes a notification', async () => {
-        const owner = env.users.user;
-        const { userId, uid } = await seedNotification(owner.username);
-
-        const res = await post('/notif/delete', owner.token, { uid });
-
-        expect(res.status).toBe(200);
-        await expect(res.json()).resolves.toEqual({});
-        const after = await env.server.stores.notification.getByUid(uid, {
-            userId,
-        });
-        expect(after).toBeNull();
-    });
-
-    it('refuses an anonymous removal', async () => {
-        const { userId, uid } = await seedNotification(env.users.other.username);
-
-        const res = await fetch(new URL('/notif/delete', env.apiOrigin), {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ uid }),
-        });
-
-        expect(res.status).toBeGreaterThanOrEqual(400);
-        const after = await env.server.stores.notification.getByUid(uid, {
-            userId,
-        });
-        expect(after?.uid).toBe(uid);
-    });
 });
@@ -183,74 +183,3 @@ describe('NotificationController.markAck', () => {
        expect(after?.acknowledged).toBeFalsy();
    });
 });
-
-// ── /notif/delete ───────────────────────────────────────────────────
-
-describe('NotificationController.remove', () => {
-    it('deletes the underlying notification row', async () => {
-        const { actor, userId } = await makeUser();
-        const created = await server.stores.notification.create({
-            userId,
-            value: { title: 't' },
-        });
-
-        const { res, captured } = makeRes();
-        await controller.remove(
-            makeReq({ body: { uid: created.uid }, actor }),
-            res,
-        );
-
-        expect(captured.body).toEqual({});
-        const after = await server.stores.notification.getByUid(
-            created.uid as string,
-            { userId },
-        );
-        expect(after).toBeNull();
-    });
-
-    it('succeeds for a uid that names no row', async () => {
-        const { actor } = await makeUser();
-        const { res, captured } = makeRes();
-        await controller.remove(
-            makeReq({ body: { uid: 'no-such-uid' }, actor }),
-            res,
-        );
-        expect(captured.body).toEqual({});
-    });
-
-    it('rejects a missing uid with 400', async () => {
-        const { actor } = await makeUser();
-        const { res } = makeRes();
-        await expect(
-            controller.remove(makeReq({ body: {}, actor }), res),
-        ).rejects.toMatchObject({ statusCode: 400 });
-    });
-
-    it('throws 401 when there is no actor on the request', async () => {
-        const { res } = makeRes();
-        await expect(
-            controller.remove(makeReq({ body: { uid: 'whatever' } }), res),
-        ).rejects.toMatchObject({ statusCode: 401 });
-    });
-
-    it("does not delete another user's notification", async () => {
-        const a = await makeUser();
-        const b = await makeUser();
-        const created = await server.stores.notification.create({
-            userId: a.userId,
-            value: {},
-        });
-
-        const { res } = makeRes();
-        await controller.remove(
-            makeReq({ body: { uid: created.uid }, actor: b.actor }),
-            res,
-        );
-
-        const after = await server.stores.notification.getByUid(
-            created.uid as string,
-            { userId: a.userId },
-        );
-        expect(after?.uid).toBe(created.uid);
-    });
-});
@@ -20,44 +20,16 @@
 import type { Request, Response } from 'express';
 import { Controller, Post } from '../../core/http/decorators.js';
 import { HttpError } from '../../core/http/HttpError.js';
+import type { NotificationService } from '../../services/notification/NotificationService.js';
 import { PuterController } from '../types.js';

-/** Both routes fire per interaction; the ceiling catches a loop, not a user. */
-const MARK_ROUTE_OPTIONS = {
-    subdomain: 'api',
-    requireUserActor: true,
-    allowFullAccessToken: true,
-    rateLimit: {
-        scope: 'notification-mark',
-        limit: 300,
-        window: 60_000,
-        key: 'user',
-    },
-} as const;
-
-/** The uid and owner a mark names, or the 400/401 the request earns. */
-const markTarget = (req: Request): { uid: string; userId: number } => {
-    const uid = req.body?.uid;
-    if (typeof uid !== 'string' || uid.length === 0) {
-        throw new HttpError(400, '`uid` must be a non-empty string', {
-            legacyCode: 'bad_request',
-        });
-    }
-    const userId = req.actor?.user?.id;
-    if (!userId)
-        throw new HttpError(401, 'Unauthorized', {
-            legacyCode: 'unauthorized',
-        });
-    return { uid, userId };
-};
-
 /**
- * GUI-facing notification endpoints. Supplement the `puter-notifications`
- * driver (which handles reads via `/drivers/call`) with the mutations the puter
- * desktop client calls directly.
+ * GUI-facing notification endpoint. Supplements the `puter-notifications`
+ * driver (which handles CRUD via `/drivers/call`) with the one mutation route
+ * the puter desktop client calls directly.
 *
- * Each goes through the NotificationService, which tells the user's other open
- * tabs (`notif.ack`, `notif.removed`) so they update immediately.
+ * It emits `outer.gui.notif.ack` via the NotificationService so other open tabs
+ * for the same user see the state change immediately.
 */
@Controller('/notif')
 export class NotificationController extends PuterController {
@@ -65,21 +37,50 @@ export class NotificationController extends PuterController {
     * POST /notif/mark-ack — user dismissed a notification. Sets `acknowledged`
     * timestamp; pushes ack event to sockets.
     */
-    @Post('/mark-ack', MARK_ROUTE_OPTIONS)
+    @Post('/mark-ack', {
+        subdomain: 'api',
+        requireUserActor: true,
+        allowFullAccessToken: true,
+        // Fires per notification interaction, so the ceiling stays
+        // generous — it is here to catch a loop, not to pace a user.
+        rateLimit: {
+            scope: 'notification-mark',
+            limit: 300,
+            window: 60_000,
+            key: 'user',
+        },
+    })
    async markAck(req: Request, res: Response): Promise<void> {
-        const { uid, userId } = markTarget(req);
-        await this.services.notification.markAcknowledged(uid, userId);
-        res.json({});
-    }
+        const uid = req.body?.uid;
+        if (typeof uid !== 'string' || uid.length === 0) {
+            throw new HttpError(400, '`uid` must be a non-empty string', {
+                legacyCode: 'bad_request',
+            });
+        }
+        const userId = req.actor?.user?.id;
+        if (!userId)
+            throw new HttpError(401, 'Unauthorized', {
+                legacyCode: 'unauthorized',
+            });

-    /**
-     * POST /notif/delete — user removed a notification from their history. A
-     * uid naming none of their rows succeeds too: it is gone either way.
-     */
-    @Post('/delete', MARK_ROUTE_OPTIONS)
-    async remove(req: Request, res: Response): Promise<void> {
-        const { uid, userId } = markTarget(req);
-        await this.services.notification.remove(uid, userId);
+        const notifService = this.services.notification as unknown as
+            | NotificationService
+            | undefined;
+        if (notifService?.markAcknowledged) {
+            await notifService.markAcknowledged(uid, userId);
+        } else {
+            // Fallback: direct store call if service isn't wired
+            await (
+                this.stores as Record<string, unknown> as {
+                    notification: {
+                        markAcknowledged: (
+                            uid: string,
+                            userId: number,
+                        ) => Promise<boolean>;
+                    };
+                }
+            ).notification.markAcknowledged(uid, userId);
+        }
        res.json({});
    }
 }
@@ -244,10 +244,7 @@ describe('OIDCController GET /auth/oidc/providers', () => {
        await callRoute('get', '/auth/oidc/providers', makeReq({}), res);
        // We configured a single `custom` provider; the live service
        // walks the config and returns its id.
-        expect(captured.body).toEqual({
-            providers: ['custom'],
-            signupOidcOnly: false,
-        });
+        expect(captured.body).toEqual({ providers: ['custom'] });
    });
 });

@@ -396,12 +396,9 @@ export class OIDCController extends PuterController {
                },
            },
            async (_req: Request, res: Response) => {
-                const [providers, policy] = await Promise.all([
-                    this.services.oidc.getEnabledProviderIds(),
-                    this.services.signup.signupPolicy(),
-                ]);
-                // The signup window drops its email form when this is set.
-                res.json({ providers, signupOidcOnly: policy.oidcOnly });
+                const providers =
+                    await this.services.oidc.getEnabledProviderIds();
+                res.json({ providers });
            },
        );

@@ -201,7 +201,6 @@ describe('PuterAIController.openaiResponses parameter forwarding', () => {
                    context_management: [{ type: 'compaction' }],
                    prompt_cache_key: 'ck',
                    prompt_cache_retention: '24h',
-                    prompt_cache_options: { ttl: '12h', prewarm: true },
                    store: true,
                    truncation: 'auto',
                    service_tier: 'default',
@@ -227,9 +226,6 @@ describe('PuterAIController.openaiResponses parameter forwarding', () => {
            context_management: [{ type: 'compaction' }],
            prompt_cache_key: 'ck',
            prompt_cache_retention: '24h',
-            // Forwarded as sent; the provider keeps only the fields it
-            // accepts.
-            prompt_cache_options: { ttl: '12h', prewarm: true },
            // forced false regardless of the client's request.
            store: false,
            truncation: 'auto',
@@ -363,18 +359,13 @@ describe('PuterAIController.openaiResponses input normalization', () => {
                role: 'user',
                content: [
                    'a bare string part',
-                    {
-                        type: 'input_text',
-                        text: 'typed text',
-                        prompt_cache_breakpoint: { mode: 'explicit', ttl: '12h' },
-                    },
+                    { type: 'input_text', text: 'typed text' },
                    { type: 'output_text', text: 'echoed text' },
                    {
                        type: 'input_image',
                        detail: 'high',
                        image_url: 'https://img.test/a.png',
                        file_id: 'file_img',
-                        prompt_cache_breakpoint: { mode: 'explicit' },
                    },
                    { type: 'input_audio', input_audio: { data: 'AAA' } },
                    {
@@ -395,18 +386,13 @@ describe('PuterAIController.openaiResponses input normalization', () => {
                role: 'user',
                content: [
                    { type: 'text', text: 'a bare string part' },
-                    {
-                        type: 'text',
-                        text: 'typed text',
-                        prompt_cache_breakpoint: { mode: 'explicit', ttl: '12h' },
-                    },
+                    { type: 'text', text: 'typed text' },
                    { type: 'text', text: 'echoed text' },
                    {
                        type: 'image_url',
                        detail: 'high',
                        image_url: { url: 'https://img.test/a.png' },
                        file_id: 'file_img',
-                        prompt_cache_breakpoint: { mode: 'explicit' },
                    },
                    { type: 'input_audio', input_audio: { data: 'AAA' } },
                    {
@@ -653,33 +639,6 @@ describe('PuterAIController.openaiResponses output items', () => {
 // -- /openai/v1/chat/completions edges -------------------------------

 describe('PuterAIController.openaiChatCompletions translation edges', () => {
-    it('forwards the prompt-cache fields to the driver', async () => {
-        const completeSpy = stubChatComplete({
-            message: { role: 'assistant', content: 'ok' },
-        });
-
-        const { res } = makeRes();
-        await controller.openaiChatCompletions(
-            makeReq({
-                body: {
-                    model: 'gpt-test',
-                    messages: [{ role: 'user', content: 'hi' }],
-                    prompt_cache_key: 'ck',
-                    prompt_cache_retention: 'in_memory',
-                    prompt_cache_options: { ttl: '30m' },
-                },
-            }),
-            res,
-        );
-
-        const args = completeSpy.mock.calls[0]![0] as Record<string, unknown>;
-        expect(args).toMatchObject({
-            prompt_cache_key: 'ck',
-            prompt_cache_retention: 'in_memory',
-            prompt_cache_options: { ttl: '30m' },
-        });
-    });
-
    it('derives tool_calls from tool_use content blocks when the message has none', async () => {
        stubChatComplete({
            message: {
@@ -511,31 +511,6 @@ describe('PuterAIController.openaiChatCompletions', () => {

        const completeArgs = completeSpy.mock.calls[0]![0];
        expect(completeArgs.provider).toBe('openai-completion');
-        expect(completeArgs.fallback).toBeUndefined();
-    });
-
-    it('forwards fallback: false so the driver stops at the first route', async () => {
-        const completeSpy = stubChatComplete({
-            message: { role: 'assistant', content: 'hi there' },
-            finish_reason: 'stop',
-            usage: { prompt_tokens: 4, completion_tokens: 2 },
-        });
-
-        const { res } = makeRes();
-        await controller.openaiChatCompletions(
-            makeReq({
-                body: {
-                    model: 'gpt-test',
-                    provider: 'openai-completion',
-                    fallback: false,
-                    messages: [{ role: 'user', content: 'hi' }],
-                },
-                actor: makeUserActor(),
-            }),
-            res,
-        );
-
-        expect(completeSpy.mock.calls[0]![0].fallback).toBe(false);
    });

    it('still pins OpenAI when the caller names no model, so the default model does not move', async () => {
@@ -447,9 +447,7 @@ export class PuterAIController extends PuterController {
                          body.reasoning_effort as ICompleteArguments['reasoning_effort'],
                  }
                : {}),
-            ...promptCacheArgsFromBody(body),
            ...openaiCompatProvider(body),
-            ...(body.fallback === false ? { fallback: false } : {}),
        };

        const result = await this.#complete(res, completeArgs);
@@ -547,7 +545,8 @@ export class PuterAIController extends PuterController {
                        }
                    } else if (ev.type === 'usage') {
                        usageDetails = ev.usageDetails as
-                            UsageDetails | undefined;
+                            | UsageDetails
+                            | undefined;
                        finishReason = ev.finish_reason as string | undefined;
                    } else if (ev.type === 'error') {
                        res.write(
@@ -650,7 +649,6 @@ export class PuterAIController extends PuterController {
                : {}),
            ...(finiteMaxTokens(body.max_tokens) ?? {}),
            ...openaiCompatProvider(body),
-            ...(body.fallback === false ? { fallback: false } : {}),
        };

        const completionId = `cmpl-${randomId()}`;
@@ -696,7 +694,8 @@ export class PuterAIController extends PuterController {
                        sendChunk(ev.text);
                    } else if (ev.type === 'usage') {
                        usageDetails = ev.usageDetails as
-                            UsageDetails | undefined;
+                            | UsageDetails
+                            | undefined;
                        finishReason = ev.finish_reason as string | undefined;
                    } else if (ev.type === 'error') {
                        res.write(
@@ -750,7 +749,8 @@ export class PuterAIController extends PuterController {
                    text: extractTextContent(
                        (
                            messageResult.message as
-                                Record<string, unknown> | undefined
+                                | Record<string, unknown>
+                                | undefined
                        )?.content,
                    ),
                    index: 0,
@@ -843,7 +843,15 @@ export class PuterAIController extends PuterController {
                          body.compaction as ICompleteArguments['compaction'],
                  }
                : {}),
-            ...promptCacheArgsFromBody(body),
+            ...(body.prompt_cache_key
+                ? { prompt_cache_key: String(body.prompt_cache_key) }
+                : {}),
+            ...(body.prompt_cache_retention
+                ? {
+                      prompt_cache_retention:
+                          body.prompt_cache_retention as ICompleteArguments['prompt_cache_retention'],
+                  }
+                : {}),
            // forced off regardless of what the caller sent — OpenAI
            // defaults `store` to true, which would persist state server-side
            // on OpenAI's end that this route gives no way to retrieve.
@@ -861,7 +869,6 @@ export class PuterAIController extends PuterController {
                  }
                : {}),
            provider: providerName,
-            ...(body.fallback === false ? { fallback: false } : {}),
        };

        const responseId = generateId('resp');
@@ -1336,33 +1343,6 @@ const openaiCompatProvider = (
    return { provider: DEFAULTS.openaiChat };
 };

-/**
- * The prompt-cache fields both OpenAI-shaped routes forward as sent; the
- * provider checks the values.
- */
-const promptCacheArgsFromBody = (
-    body: Record<string, unknown>,
-): Pick<
-    ICompleteArguments,
-    'prompt_cache_key' | 'prompt_cache_retention' | 'prompt_cache_options'
-> => ({
-    ...(body.prompt_cache_key
-        ? { prompt_cache_key: String(body.prompt_cache_key) }
-        : {}),
-    ...(body.prompt_cache_retention
-        ? {
-              prompt_cache_retention:
-                  body.prompt_cache_retention as ICompleteArguments['prompt_cache_retention'],
-          }
-        : {}),
-    ...(body.prompt_cache_options
-        ? {
-              prompt_cache_options:
-                  body.prompt_cache_options as ICompleteArguments['prompt_cache_options'],
-          }
-        : {}),
-});
-
 const randomId = (): string => crypto.randomUUID().replace(/-/g, '');
 const generateId = (prefix: string): string => `${prefix}_${randomId()}`;

@@ -1610,24 +1590,12 @@ const parseJsonMaybe = (value: unknown): unknown => {
    }
 };

-/** An OpenAI `prompt_cache_breakpoint` marker, kept on the translated part. */
-const cacheBreakpointOf = (
-    p: Record<string, unknown>,
-): { prompt_cache_breakpoint?: unknown } =>
-    p.prompt_cache_breakpoint && typeof p.prompt_cache_breakpoint === 'object'
-        ? { prompt_cache_breakpoint: p.prompt_cache_breakpoint }
-        : {};
-
 const normalizeContentPart = (part: unknown): Record<string, unknown> => {
    if (typeof part === 'string') return { type: 'text', text: part };
    if (!part || typeof part !== 'object') return { type: 'text', text: '' };
    const p = part as Record<string, unknown>;
    if (p.type === 'input_text' || p.type === 'output_text') {
-        return {
-            type: 'text',
-            text: String(p.text ?? ''),
-            ...cacheBreakpointOf(p),
-        };
+        return { type: 'text', text: String(p.text ?? '') };
    }
    if (p.type === 'input_image') {
        return {
@@ -1635,7 +1603,6 @@ const normalizeContentPart = (part: unknown): Record<string, unknown> => {
            ...(p.detail ? { detail: p.detail } : {}),
            ...(p.image_url ? { image_url: { url: p.image_url } } : {}),
            ...(p.file_id ? { file_id: p.file_id } : {}),
-            ...cacheBreakpointOf(p),
        };
    }
    if (p.type === 'input_audio')
@@ -1647,7 +1614,6 @@ const normalizeContentPart = (part: unknown): Record<string, unknown> => {
            ...(p.file_id ? { file_id: p.file_id } : {}),
            ...(p.file_url ? { file_url: p.file_url } : {}),
            ...(p.filename ? { filename: p.filename } : {}),
-            ...cacheBreakpointOf(p),
        };
    }
    return p;
@@ -324,18 +324,6 @@ describe('parseAnthropicRequest', () => {
        expect(args.provider).toBe('claude');
        expect(args.normalize).toBe(false);
        expect(args.streamToolInput).toBe(true);
-        expect(args.fallback).toBeUndefined();
-    });
-
-    it('forwards fallback: false and nothing else for fallback', () => {
-        expect(
-            parseAnthropicRequest({ messages: [], fallback: false }, headers)
-                .fallback,
-        ).toBe(false);
-        expect(
-            parseAnthropicRequest({ messages: [], fallback: 'no' }, headers)
-                .fallback,
-        ).toBeUndefined();
    });

    it('maps thinking, tool_choice, stop_sequences, top_p/top_k', () => {
@@ -431,7 +431,6 @@ export const parseAnthropicRequest = (
            : {}),
        ...(betas.length ? { anthropicBetas: betas } : {}),
        provider: toStringOrEmpty(body.provider) || 'claude',
-        ...(body.fallback === false ? { fallback: false } : {}),
    };
    // Silently ignored: metadata, service_tier, inference_geo, container,
    // fallbacks, diagnostics.
@@ -19,9 +19,8 @@

 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import type { AddressInfo } from 'node:net';
 import path from 'node:path';
-import express, { type Request, type Response } from 'express';
+import type { Request, Response } from 'express';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { PuterRouter } from '../../core/http/PuterRouter.js';
 import type { RouteDescriptor } from '../../core/http/types.js';
@@ -112,7 +111,6 @@ const callGetHandler = async (
    let captured: { filename?: string; root?: string } = {};
    const req = {} as Request;
    const res = {
-        setHeader: vi.fn(),
        sendFile: vi.fn((filename: string, opts: { root: string }) => {
            captured = { filename, root: opts.root };
        }),
@@ -240,48 +238,6 @@ describe('StaticAssetsController puterjs_root', () => {
    });
 });

-// ── push-sw.js caching ──────────────────────────────────────────────
-
-/** Serves the route's handler over real HTTP and returns the response. */
-const fetchThroughExpress = async (router: PuterRouter, routePath: string) => {
-    const route = findRoute(router, 'get', routePath);
-    if (!route) throw new Error(`No GET ${routePath} registered`);
-    const app = express();
-    app.get(routePath, (req, res, next) => route.handler(req, res, next));
-    const listener = app.listen(0);
-    await new Promise((resolve) => listener.once('listening', resolve));
-    try {
-        const { port } = listener.address() as AddressInfo;
-        return await fetch(`http://127.0.0.1:${port}${routePath}`);
-    } finally {
-        listener.close();
-    }
-};
-
-describe('StaticAssetsController push-sw.js', () => {
-    it.each([
-        ['client_libs_root', 'puter.js/push-sw.js'],
-        ['puterjs_root', 'push-sw.js'],
-    ] as const)(
-        'lets the CDN keep it for five minutes from %s',
-        async (configKey, file) => {
-            const root = makeTempDir();
-            mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
-            writeFileSync(path.join(root, file), '/* worker */');
-            const router = buildController({ [configKey]: root });
-
-            for (const route of ['/push-sw.js', '/v2/push-sw.js']) {
-                const response = await fetchThroughExpress(router, route);
-                expect(response.status).toBe(200);
-                expect(response.headers.get('cache-control')).toBe(
-                    'public, max-age=0, s-maxage=300',
-                );
-                expect(await response.text()).toBe('/* worker */');
-            }
-        },
-    );
-});
-
 // ── gui_assets_root ─────────────────────────────────────────────────

 describe('StaticAssetsController gui_assets_root', () => {
@@ -23,9 +23,6 @@ import path from 'node:path';
 import { PuterController } from '../types.js';
 import type { PuterRouter } from '../../core/http/PuterRouter';

-// Sites import push-sw.js by URL, so the CDN refetches it within five minutes.
-const PUSH_WORKER_CACHE_CONTROL = 'public, max-age=0, s-maxage=300';
-
 /**
 * Static asset routes.
 *
@@ -61,7 +58,6 @@ export class StaticAssetsController extends PuterController {
            // `/v2/push-sw.js` is the path older docs gave.
            for (const route of ['/push-sw.js', '/v2/push-sw.js']) {
                router.get(route, { subdomain: 'js' }, (_req, res) => {
-                    res.setHeader('Cache-Control', PUSH_WORKER_CACHE_CONTROL);
                    res.sendFile('puter.js/push-sw.js', { root });
                });
            }
@@ -112,10 +108,6 @@ export class StaticAssetsController extends PuterController {
                });
                for (const route of ['/push-sw.js', '/v2/push-sw.js']) {
                    router.get(route, { subdomain: 'js' }, (_req, res) => {
-                        res.setHeader(
-                            'Cache-Control',
-                            PUSH_WORKER_CACHE_CONTROL,
-                        );
                        res.sendFile('push-sw.js', { root: puterjsRoot });
                    });
                }
@@ -87,11 +87,6 @@ export interface KnownContextFields {
     * different provider's translation of it.
     */
    strictUpstreamErrors: boolean;
-    /**
-     * Set while Puter files something into an account for it (mail delivery),
-     * so filesystem events never report that write as the request actor's own.
-     */
-    platformWrite: boolean;
 }

 // Every key of `KnownContextFields`, checked both ways by the compiler, so
@@ -105,7 +100,6 @@ const KNOWN_KEY_FLAGS: Record<keyof KnownContextFields, true> = {
    keepDriverSlot: true,
    upstreamSignal: true,
    strictUpstreamErrors: true,
-    platformWrite: true,
 };
 const KNOWN_KEYS: ReadonlySet<string> = new Set(Object.keys(KNOWN_KEY_FLAGS));

@@ -836,34 +836,6 @@ describe('requireVerifiedAccount', () => {
        expectHttpError(got, 403, 'card_verification_required');
    });

-    it('asks an email-gate-last account for card, then phone, then email', () => {
-        const pending = {
-            uuid: 'u-1',
-            requires_email_confirmation: true,
-            email_confirmed: false,
-            requires_phone_verification: true,
-            requires_card_verification: true,
-            metadata: { emailGateLast: true },
-        };
-        const gateFor = (user: Record<string, unknown>) =>
-            runGate(requireVerifiedAccount(), { actor: { user } });
-        expectHttpError(gateFor(pending), 403, 'card_verification_required');
-        expectHttpError(
-            gateFor({ ...pending, requires_card_verification: false }),
-            403,
-            'phone_verification_required',
-        );
-        expectHttpError(
-            gateFor({
-                ...pending,
-                requires_card_verification: false,
-                requires_phone_verification: false,
-            }),
-            403,
-            'email_confirmation_required',
-        );
-    });
-
    it('returns 403 two_factor_required for a seat whose team requires 2FA', async () => {
        const teams = { getOrgSeat: async () => ({ require_2fa: 1 }) };
        const got = await runGateAsync(requireTeam2fa(teams), {
@@ -32,7 +32,6 @@ import {
    type CardFallbackDeps,
 } from '../../../util/cardFallback';
 import { reserveUsernames } from '../../../util/reservedUsernames';
-import { isEmailGateLast } from '../../../util/verificationOrder';
 import {
    isAccountContext,
    isAppActor,
@@ -310,25 +309,11 @@ export const requireVerifiedAccount = (): RequestHandler =>
 export const assertVerifiedAccount = (
    user: AccountGateUser | undefined,
 ): void => {
-    const assertEmail = () => {
-        if (user?.requires_email_confirmation && !user?.email_confirmed) {
-            throw new HttpError(403, 'Please confirm your email to continue', {
-                legacyCode: 'email_confirmation_required',
-            });
-        }
-    };
-    const assertCard = () => {
-        if (user?.requires_card_verification) {
-            throw new HttpError(403, 'Please verify your card to continue', {
-                legacyCode: 'card_verification_required',
-            });
-        }
-    };
-    // Email → phone → card, or card → phone → email for an email-gate-last
-    // account, so the client is sent to the gate it has to clear next.
-    const emailLast = isEmailGateLast(user);
-    if (emailLast) assertCard();
-    else assertEmail();
+    if (user?.requires_email_confirmation && !user?.email_confirmed) {
+        throw new HttpError(403, 'Please confirm your email to continue', {
+            legacyCode: 'email_confirmation_required',
+        });
+    }
    if (user?.requires_phone_verification) {
        throw new HttpError(
            403,
@@ -338,8 +323,11 @@ export const assertVerifiedAccount = (
            },
        );
    }
-    if (emailLast) assertEmail();
-    else assertCard();
+    if (user?.requires_card_verification) {
+        throw new HttpError(403, 'Please verify your card to continue', {
+            legacyCode: 'card_verification_required',
+        });
+    }
    // A team seat signs in on a password its administrator still holds,
    // so it reaches nothing until it has replaced that password.
    if (user?.requires_password_change) {
@@ -187,9 +187,9 @@ describe('createUserSubdomainNotFound', () => {
    });

    it('passes through reserved subdomains (api, js, native apps, etc.)', () => {
-        // `api`, `js`, `dav`, `docs`, `developer`, `about`, `apps`,
+        // `api`, `js`, `dav`, `docs`, `developer`, `editor`, `pdf`,
        // `puter-app-icons`, etc. all pass through.
-        for (const sub of ['api', 'js', 'docs', 'about', 'puter-app-icons']) {
+        for (const sub of ['api', 'js', 'docs', 'editor', 'puter-app-icons']) {
            const { out, next } = run(
                createUserSubdomainNotFound(config),
                makeReq({
@@ -865,13 +865,13 @@ describe('createNativeAppStatic', () => {

    beforeAll(() => {
        root = mkdtempSync(nodePath.join(tmpdir(), 'native-apps-'));
-        mkdirSync(nodePath.join(root, 'about', 'assets'), { recursive: true });
+        mkdirSync(nodePath.join(root, 'editor', 'assets'), { recursive: true });
        writeFileSync(
-            nodePath.join(root, 'about', 'index.html'),
-            '<h1>about</h1>',
+            nodePath.join(root, 'editor', 'index.html'),
+            '<h1>editor</h1>',
        );
        writeFileSync(
-            nodePath.join(root, 'about', 'assets', 'app.js'),
+            nodePath.join(root, 'editor', 'assets', 'app.js'),
            'console.log(1);',
        );
        mkdirSync(nodePath.join(root, 'docs', 'dist'), { recursive: true });
@@ -893,7 +893,7 @@ describe('createNativeAppStatic', () => {

    it('leaves a native app name alone on a host outside our domains', async () => {
        const req = staticReq({
-            subdomains: ['com', 'example', 'about'],
+            subdomains: ['com', 'example', 'editor'],
            path: '/index.html',
        });
        (req as Request & { is_custom_domain?: boolean }).is_custom_domain =
@@ -907,7 +907,7 @@ describe('createNativeAppStatic', () => {
        const { out, next } = await runStatic(
            createNativeAppStatic(config),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/index.html',
            }),
        );
@@ -915,24 +915,17 @@ describe('createNativeAppStatic', () => {
        expect(next).toHaveBeenCalledTimes(1);
    });

-    // `editor`, `markus` and `pdf` are web apps on standard host routing,
-    // even with a folder of their own under the native apps root.
-    it.each(['api', 'editor', 'markus', 'pdf'])(
-        'passes %s through, as it is not a native app',
-        async (sub) => {
-            mkdirSync(nodePath.join(root, sub), { recursive: true });
-            writeFileSync(nodePath.join(root, sub, 'index.html'), sub);
-            const { out, next } = await runStatic(
-                withRoot(),
-                staticReq({
-                    subdomains: ['localhost', 'puter', sub],
-                    path: '/index.html',
-                }),
-            );
-            expect(out.sent).toBeUndefined();
-            expect(next).toHaveBeenCalledTimes(1);
-        },
-    );
+    it('passes through subdomains that are not native apps', async () => {
+        const { out, next } = await runStatic(
+            withRoot(),
+            staticReq({
+                subdomains: ['localhost', 'puter', 'api'],
+                path: '/index.html',
+            }),
+        );
+        expect(out.sent).toBeUndefined();
+        expect(next).toHaveBeenCalledTimes(1);
+    });

    it('passes through when there is no subdomain at all', async () => {
        const { next } = await runStatic(
@@ -946,13 +939,13 @@ describe('createNativeAppStatic', () => {
        const { out, next } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/index.html',
            }),
        );
        expect(out.sent).toEqual({
            path: '/index.html',
-            root: nodePath.join(root, 'about'),
+            root: nodePath.join(root, 'editor'),
        });
        expect(next).not.toHaveBeenCalled();
    });
@@ -961,11 +954,11 @@ describe('createNativeAppStatic', () => {
        const { out } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'ABOUT'],
+                subdomains: ['localhost', 'puter', 'EDITOR'],
                path: '/index.html',
            }),
        );
-        expect(out.sent?.root).toBe(nodePath.join(root, 'about'));
+        expect(out.sent?.root).toBe(nodePath.join(root, 'editor'));
    });

    it('serves docs out of its dist/ subdirectory, not the app root', async () => {
@@ -986,7 +979,7 @@ describe('createNativeAppStatic', () => {
        const { out, next } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/assets',
                originalUrl: '/assets?v=2',
            }),
@@ -1002,7 +995,7 @@ describe('createNativeAppStatic', () => {
        const { out } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/assets/',
            }),
        );
@@ -1014,7 +1007,7 @@ describe('createNativeAppStatic', () => {
        const { out, next } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/nope.html',
            }),
        );
@@ -1026,7 +1019,7 @@ describe('createNativeAppStatic', () => {
        const { next } = await runStatic(
            withRoot(),
            staticReq({
-                subdomains: ['localhost', 'puter', 'about'],
+                subdomains: ['localhost', 'puter', 'editor'],
                path: '/index.html',
            }),
            new Error('send failed'),
@@ -1039,7 +1032,7 @@ describe('createNativeAppStatic', () => {
            runStatic(
                withRoot(),
                staticReq({
-                    subdomains: ['localhost', 'puter', 'about'],
+                    subdomains: ['localhost', 'puter', 'editor'],
                    path: '/../../etc/passwd',
                }),
            ),
@@ -27,7 +27,15 @@ import { HttpError, isHttpError } from '../HttpError';
 import { isLocalWorkerHost } from './localWorkerProxy';

 /** Native-app subdomains served via `nativeAppStatic`. */
-const NATIVE_APP_SUBDOMAINS = ['about', 'developer', 'docs', 'apps'] as const;
+const NATIVE_APP_SUBDOMAINS = [
+    'about',
+    'developer',
+    'docs',
+    'editor',
+    'markus',
+    'pdf',
+    'apps',
+] as const;

 /** Subset served out of a `dist/` subdirectory rather than the app root. */
 const NATIVE_APPS_WITH_DIST = new Set(['docs', 'developer']);
@@ -103,10 +111,6 @@ export const subdomainLabelOf = (
    return label && !label.includes('.') ? label : undefined;
 };

-/** Whether core itself answers `<name>.<domain>` (`www` redirects to the root). */
-export const isReservedSubdomain = (name: string): boolean =>
-    name === 'www' || RESERVED_SUBDOMAINS.has(name);
-
 /**
 * Record a claim on `<name>.<domain>`. Throws on a malformed or uppercase
 * label, a subdomain core already handles, or a name that is already claimed.
@@ -119,7 +123,7 @@ export const addClaimedSubdomain = (
    if (typeof name !== 'string' || !SUBDOMAIN_LABEL.test(name)) {
        throw new Error(`Invalid subdomain label: ${JSON.stringify(name)}`);
    }
-    if (isReservedSubdomain(name)) {
+    if (name === 'www' || RESERVED_SUBDOMAINS.has(name)) {
        throw new Error(`Subdomain '${name}' is reserved`);
    }
    if (claims.has(name)) {
@@ -1,163 +0,0 @@
-/*
- * Copyright (C) 2024-present Puter Technologies Inc.
- *
- * This file is part of Puter.
- *
- * Puter is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-import { EventEmitter } from 'node:events';
-import type { NextFunction, Request, RequestHandler, Response } from 'express';
-import { describe, expect, it, vi } from 'vitest';
-import { isHttpError } from '../HttpError';
-import {
-    createLargeJsonBodyParser,
-    DEFAULT_JSON_LIMIT_BYTES,
-} from './largeJsonBody';
-
-const MiB = 1024 * 1024;
-
-// A complete request with no socket reads as already consumed to body-parser,
-// so the parsers call straight through, leaving any preset `body` in place.
-const makeReq = (
-    bytes: number | undefined,
-    user: string | null = 'u1',
-    body?: unknown,
-) =>
-    ({
-        complete: true,
-        body,
-        headers: {
-            'content-type': 'application/json',
-            ...(bytes === undefined ? {} : { 'content-length': String(bytes) }),
-            ...(user ? { authorization: user } : {}),
-        },
-    }) as unknown as Request;
-
-const makeRes = () => {
-    const res = new EventEmitter() as EventEmitter & {
-        setHeader: ReturnType<typeof vi.fn>;
-    };
-    res.setHeader = vi.fn();
-    return res;
-};
-
-const authProbe = vi.fn<RequestHandler>((req, _res, next) => {
-    if (req.headers.authorization) {
-        (req as { actor?: unknown }).actor = {
-            user: { uuid: req.headers.authorization },
-        };
-    }
-    next();
-});
-
-const run = (mw: RequestHandler, req: Request, res = makeRes()) =>
-    new Promise<{ err: unknown; res: ReturnType<typeof makeRes> }>(
-        (resolve) => {
-            mw(
-                req,
-                res as unknown as Response,
-                ((err?: unknown) => resolve({ err, res })) as NextFunction,
-            );
-        },
-    );
-
-const statusOf = (err: unknown) => (isHttpError(err) ? err.statusCode : err);
-
-describe('createLargeJsonBodyParser', () => {
-    const create = ({
-        budgetBytes = 200 * MiB,
-        perUserBytes = 128 * MiB,
-        accepts,
-    }: {
-        budgetBytes?: number;
-        perUserBytes?: number;
-        accepts?: (req: Request) => boolean;
-    } = {}) =>
-        createLargeJsonBodyParser({
-            authProbe,
-            limitBytes: 128 * MiB,
-            budgetBytes,
-            perUserBytes,
-            accepts,
-        });
-
-    it.each([
-        ['no Content-Length', undefined],
-        ['a body within the default limit', DEFAULT_JSON_LIMIT_BYTES],
-        ['a body over the large limit', 128 * MiB + 1],
-    ])('leaves %s to the global parser without probing', async (_, bytes) => {
-        authProbe.mockClear();
-        const { err } = await run(create(), makeReq(bytes));
-        expect(err).toBeUndefined();
-        expect(authProbe).not.toHaveBeenCalled();
-    });
-
-    it('leaves an unauthenticated large body to the global parser', async () => {
-        const mw = create({ budgetBytes: 60 * MiB });
-        const { err } = await run(mw, makeReq(60 * MiB, null));
-        expect(err).toBeUndefined();
-        // Nothing was charged, so a signed-in caller still fits.
-        expect((await run(mw, makeReq(60 * MiB))).err).toBeUndefined();
-    });
-
-    it('charges nothing for a client that left during the probe', async () => {
-        const mw = create({ budgetBytes: 60 * MiB });
-        const gone = Object.assign(makeRes(), { closed: true });
-        expect((await run(mw, makeReq(60 * MiB), gone)).err).toBeUndefined();
-        expect((await run(mw, makeReq(60 * MiB))).err).toBeUndefined();
-    });
-
-    it('refuses with 503 past the budget until a response closes', async () => {
-        const mw = create({ budgetBytes: 130 * MiB });
-        const first = await run(mw, makeReq(60 * MiB, 'u1'));
-        await run(mw, makeReq(60 * MiB, 'u2'));
-
-        const refused = await run(mw, makeReq(60 * MiB, 'u3'));
-        expect(statusOf(refused.err)).toBe(503);
-        // Load shedding is recorded, not paged.
-        expect(isHttpError(refused.err) && refused.err.alarmSeverity).toBe(
-            'info',
-        );
-        expect(refused.res.setHeader).toHaveBeenCalledWith('Retry-After', '5');
-
-        first.res.emit('close');
-        expect((await run(mw, makeReq(60 * MiB, 'u3'))).err).toBeUndefined();
-    });
-
-    it("refuses one user's bodies with 429 past their share", async () => {
-        const mw = create({ perUserBytes: 100 * MiB });
-        const first = await run(mw, makeReq(60 * MiB, 'u1'));
-
-        const refused = await run(mw, makeReq(60 * MiB, 'u1'));
-        expect(statusOf(refused.err)).toBe(429);
-        expect(refused.res.setHeader).toHaveBeenCalledWith('Retry-After', '5');
-        // Another user isn't held back by it.
-        expect((await run(mw, makeReq(60 * MiB, 'u2'))).err).toBeUndefined();
-
-        first.res.emit('close');
-        expect((await run(mw, makeReq(60 * MiB, 'u1'))).err).toBeUndefined();
-    });
-
-    it('refuses with 413 a parsed body `accepts` turns down', async () => {
-        const mw = create({
-            accepts: (req) => (req.body as { ok?: boolean }).ok === true,
-        });
-        const refused = await run(mw, makeReq(60 * MiB, 'u1', { ok: false }));
-        expect(statusOf(refused.err)).toBe(413);
-        expect(
-            (await run(mw, makeReq(60 * MiB, 'u2', { ok: true }))).err,
-        ).toBeUndefined();
-    });
-});
@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2024-present Puter Technologies Inc.
- *
- * This file is part of Puter.
- *
- * Puter is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-import express, { type Request, type RequestHandler } from 'express';
-import { actorUid } from '../../actor';
-import { HttpError } from '../HttpError';
-
-/** The global JSON parser's limit, which applies before auth. */
-export const DEFAULT_JSON_LIMIT_BYTES = 50 * 1024 * 1024;
-
-interface LargeJsonBodyOptions {
-    /** The global auth probe; it skips requests that already carry an actor. */
-    authProbe: RequestHandler;
-    limitBytes: number;
-    /** Declared bytes of large bodies a process holds at once. */
-    budgetBytes: number;
-    /** Declared bytes of large bodies one user holds at once. */
-    perUserBytes: number;
-    /** Checked once the body is parsed; a body it refuses gets a 413. */
-    accepts?: (req: Request) => boolean;
-}
-
-/**
- * Parses JSON bodies over the default limit, up to `limitBytes`, once the
- * caller's header or cookie credential resolves. Unauthenticated requests and
- * requests without a Content-Length fall through to the global parser and its
- * limit.
- *
- * The parsed body lives as long as the request, so a body's bytes count against
- * both budgets until its response closes. Over the user's budget gets a 429,
- * over the process budget a 503.
- */
-export const createLargeJsonBodyParser = ({
-    authProbe,
-    limitBytes,
-    budgetBytes,
-    perUserBytes,
-    accepts,
-}: LargeJsonBodyOptions): RequestHandler => {
-    const json = express.json({ limit: limitBytes });
-    const textAsJson = express.json({
-        limit: limitBytes,
-        type: (req) =>
-            req.headers['content-type'] === 'text/plain;actually=json',
-    });
-    let inFlightBytes = 0;
-    const inFlightByUser = new Map<string, number>();
-
-    return (req, res, next) => {
-        const declared = Number(req.headers['content-length']);
-        if (!(declared > DEFAULT_JSON_LIMIT_BYTES && declared <= limitBytes)) {
-            next();
-            return;
-        }
-        void authProbe(req, res, () => {
-            // `res.closed`: the client left during the probe, so `close` has
-            // already fired and would never release a charge.
-            if (!req.actor || res.closed) {
-                next();
-                return;
-            }
-            const user = req.actor.user.uuid ?? actorUid(req.actor);
-            const userBytes = inFlightByUser.get(user) ?? 0;
-            if (userBytes + declared > perUserBytes) {
-                res.setHeader('Retry-After', '5');
-                next(
-                    new HttpError(
-                        429,
-                        'Too many large requests in progress for this account',
-                        { legacyCode: 'too_many_requests' },
-                    ),
-                );
-                return;
-            }
-            if (inFlightBytes + declared > budgetBytes) {
-                res.setHeader('Retry-After', '5');
-                next(
-                    new HttpError(503, 'Too many large requests in progress', {
-                        code: 'large_body_capacity',
-                        // Load shedding, not a fault: record it, don't page.
-                        alarmSeverity: 'info',
-                    }),
-                );
-                return;
-            }
-            inFlightBytes += declared;
-            inFlightByUser.set(user, userBytes + declared);
-            res.once('close', () => {
-                inFlightBytes -= declared;
-                const left = (inFlightByUser.get(user) ?? 0) - declared;
-                if (left > 0) inFlightByUser.set(user, left);
-                else inFlightByUser.delete(user);
-            });
-            json(req, res, (err?: unknown) => {
-                if (err) {
-                    next(err);
-                    return;
-                }
-                textAsJson(req, res, (err?: unknown) => {
-                    if (err) {
-                        next(err);
-                        return;
-                    }
-                    if (accepts && !accepts(req)) {
-                        // The same answer the default limit gives.
-                        next(
-                            new HttpError(413, 'request entity too large', {
-                                legacyCode: 'client_bad_request',
-                            }),
-                        );
-                        return;
-                    }
-                    next();
-                });
-            });
-        });
-    };
-};
@@ -84,10 +84,6 @@ export function sweepMemoryWindows() {
        )
            memoryWindows.delete(k);
    }
-    for (const [k, entry] of memoryCounters) {
-        if (entry.index < Math.floor(now / entry.windowMs) - 1)
-            memoryCounters.delete(k);
-    }
 }

 {
@@ -159,97 +155,6 @@ async function peekMemory(key, limit, windowMs) {
    return timestamps.length < limit;
 }

-// -- Counted claims --------------------------------------------------
-//
-// `claim` keeps a member per unit, which is fine for a few units and not for
-// thousands. The counted form keeps two counters per key, the current fixed
-// window and the one before it, and slides by weighting the previous one by
-// how much of it the window still covers. It can be off by a little at window
-// edges, and its buckets are separate from the other forms'.
-
-/** The sliding-window estimate from the two fixed windows it overlaps. */
-const slidingCount = (previous, current, now, windowMs) =>
-    previous * (1 - (now % windowMs) / windowMs) + current;
-
-/** How many of `units` a counted claim that left `used` spent may keep. */
-const countedAdmits = (used, limit, units) =>
-    units - Math.min(units, Math.max(0, Math.ceil(used - limit)));
-
-/** Key → `{ index, current, previous, windowMs }`, swept with the windows. */
-const memoryCounters = new Map();
-
-async function claimCountMemory(key, limit, windowMs, units) {
-    const now = Date.now();
-    const index = Math.floor(now / windowMs);
-    let entry = memoryCounters.get(key);
-    if (!entry) {
-        if (memoryCounters.size >= MEMORY_MAX_KEYS) {
-            memoryCounters.delete(memoryCounters.keys().next().value);
-        }
-        entry = { index, current: 0, previous: 0, windowMs };
-        memoryCounters.set(key, entry);
-    } else if (entry.index !== index) {
-        entry.previous = entry.index === index - 1 ? entry.current : 0;
-        entry.current = 0;
-        entry.index = index;
-    }
-    entry.windowMs = windowMs;
-    const used = slidingCount(entry.previous, entry.current, now, windowMs);
-    const admitted = countedAdmits(used + units, limit, units);
-    entry.current += admitted;
-    return admitted;
-}
-
-async function claimCountRedis(redis, key, limit, windowMs, units) {
-    const now = Date.now();
-    const index = Math.floor(now / windowMs);
-    // The hash tag keeps both windows in one slot, so one MULTI reads both.
-    const current = `ratec:{${key}}:${index}`;
-    const results = await redis
-        .multi()
-        .incrby(current, units)
-        .pexpire(current, 2 * windowMs)
-        .get(`ratec:{${key}}:${index - 1}`)
-        .exec();
-    const used = slidingCount(
-        Number(multiResult(results, 2) ?? 0),
-        Number(multiResult(results, 0)),
-        now,
-        windowMs,
-    );
-    const admitted = countedAdmits(used, limit, units);
-    if (admitted < units) await redis.decrby(current, units - admitted);
-    return admitted;
-}
-
-async function claimCountKv(kv, key, limit, windowMs, units) {
-    const now = Date.now();
-    const index = Math.floor(now / windowMs);
-    const current = `ratec:${key}:${index}`;
-    const [counted, previous] = await Promise.all([
-        kv.incr({
-            key: current,
-            pathAndAmountMap: { '': units },
-            expireAt: Math.ceil((now + 2 * windowMs) / 1000),
-        }),
-        kv.get({ key: `ratec:${key}:${index - 1}` }),
-    ]);
-    const used = slidingCount(
-        Number(previous.res ?? 0),
-        Number(counted.res),
-        now,
-        windowMs,
-    );
-    const admitted = countedAdmits(used, limit, units);
-    if (admitted < units) {
-        await kv.decr({
-            key: current,
-            pathAndAmountMap: { '': units - admitted },
-        });
-    }
-    return admitted;
-}
-
 // -- Redis backend ---------------------------------------------------

 // ioredis MULTI/EXEC reports per-command failures inside the exec() result
@@ -570,10 +475,6 @@ function instrumentBackendPair(name, pair) {
            withSpan('rate_limit.claim', attrs, () =>
                pair.claim(key, limit, windowMs, units),
            ),
-        count: (key, limit, windowMs, units) =>
-            withSpan('rate_limit.count', attrs, () =>
-                pair.count(key, limit, windowMs, units),
-            ),
        acquire: (key, limit) =>
            withSpan('rate_limit.acquire', attrs, () =>
                pair.acquire(key, limit),
@@ -585,7 +486,6 @@ const memoryBackendPair = instrumentBackendPair('memory', {
    rate: checkMemory,
    peek: peekMemory,
    claim: claimMemory,
-    count: claimCountMemory,
    acquire: acquireMemoryConcurrent,
 });

@@ -636,8 +536,6 @@ export function configureRateLimit({
                peekRedis(redis, key, limit, windowMs),
            claim: (key, limit, windowMs, units) =>
                claimRedis(redis, key, limit, windowMs, units),
-            count: (key, limit, windowMs, units) =>
-                claimCountRedis(redis, key, limit, windowMs, units),
            acquire: (key, limit) => acquireRedisConcurrent(redis, key, limit),
        });
    }
@@ -647,8 +545,6 @@ export function configureRateLimit({
            peek: (key, limit) => peekKv(kv, key, limit),
            claim: (key, limit, windowMs, units) =>
                claimKv(kv, key, limit, windowMs, units),
-            count: (key, limit, windowMs, units) =>
-                claimCountKv(kv, key, limit, windowMs, units),
            acquire: (key, limit) => acquireKvConcurrent(kv, key, limit),
        });
    }
@@ -978,32 +874,6 @@ export async function claimRateLimit(key, limit, windowMs, units, backend) {
    }
 }

-/**
- * `claimRateLimit` for budgets measured in many units per call: a claim costs
- * the same however many units it spends (see "Counted claims" above). Its
- * buckets are its own, so a key is only ever claimed one way. Fails open,
- * admitting every unit.
- */
-export async function claimCountedRateLimit(
-    key,
-    limit,
-    windowMs,
-    units,
-    backend,
-) {
-    if (!(units > 0)) return 0;
-    const bk = resolveBackend(backend);
-    try {
-        return await bk.count(key, limit, windowMs, units);
-    } catch (err) {
-        console.error(
-            '[rate-limit] imperative counted claim failed, failing open:',
-            err,
-        );
-        return units;
-    }
-}
-
 /**
 * Charge a route-shaped rate-limit spec from inside a handler.
 *
@@ -37,7 +37,6 @@ import {
    acquireDriverConcurrent,
    checkDriverRateLimit,
    checkRateLimit,
-    claimCountedRateLimit,
    claimRateLimit,
    concurrencyGate,
    consumeRouteRateLimit,
@@ -1488,13 +1487,6 @@ describe('rate + concurrent limiting — kv backend', () => {
        expect(await claimRateLimit(key, 5, 60_000, 1)).toBe(0);
    });

-    it('claims counted units, admitting only what fits', async () => {
-        const key = uniqueScope();
-        expect(await claimCountedRateLimit(key, 5, 60_000, 3)).toBe(3);
-        expect(await claimCountedRateLimit(key, 5, 60_000, 3)).toBe(2);
-        expect(await claimCountedRateLimit(key, 5, 60_000, 1)).toBe(0);
-    });
-
    it('claims against a full bucket as full while expired rows are unswept', async () => {
        const key = uniqueScope();
        await seedUnswept(`rate:${key}:`, 3);
@@ -2018,103 +2010,6 @@ describe('acquireConcurrent (imperative)', () => {
    });
 });

-describe('claimCountedRateLimit', () => {
-    const uniqueKey = () =>
-        `counted-${Math.random().toString(36).slice(2, 10)}`;
-    const WINDOW = 10_000;
-    /** The start of a fixed window, so nothing before it carries in. */
-    const windowStart = (n) => vi.setSystemTime(n * WINDOW);
-
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-
-    describe.each([
-        ['memory', () => configureRateLimit()],
-        [
-            'redis',
-            () =>
-                configureRateLimit({
-                    default: 'redis',
-                    redis: new RedisMock(),
-                }),
-        ],
-    ])('%s backend', (_name, configure) => {
-        beforeEach(() => {
-            configure();
-            vi.useFakeTimers({ toFake: ['Date'] });
-            windowStart(1_000);
-        });
-
-        it('admits up to the limit and spends only what fits', async () => {
-            const key = uniqueKey();
-            expect(await claimCountedRateLimit(key, 5, WINDOW, 3)).toBe(3);
-            expect(await claimCountedRateLimit(key, 5, WINDOW, 3)).toBe(2);
-            expect(await claimCountedRateLimit(key, 5, WINDOW, 1)).toBe(0);
-        });
-
-        it('spends thousands of units in one claim', async () => {
-            const key = uniqueKey();
-            expect(
-                await claimCountedRateLimit(key, 15_000, WINDOW, 6_000),
-            ).toBe(6_000);
-            expect(
-                await claimCountedRateLimit(key, 15_000, WINDOW, 10_000),
-            ).toBe(9_000);
-        });
-
-        it('carries the previous window by how much of it is still inside', async () => {
-            const key = uniqueKey();
-            expect(await claimCountedRateLimit(key, 100, WINDOW, 100)).toBe(
-                100,
-            );
-            // A quarter into the next window, 75 of those still count.
-            vi.setSystemTime(1_001 * WINDOW + WINDOW / 4);
-            expect(await claimCountedRateLimit(key, 100, WINDOW, 50)).toBe(25);
-            // Two windows on, nothing carries.
-            windowStart(1_003);
-            expect(await claimCountedRateLimit(key, 100, WINDOW, 100)).toBe(
-                100,
-            );
-        });
-
-        it('keeps its buckets apart from claimRateLimit', async () => {
-            const key = uniqueKey();
-            expect(await claimCountedRateLimit(key, 2, WINDOW, 2)).toBe(2);
-            expect(await claimRateLimit(key, 2, WINDOW, 2)).toBe(2);
-        });
-    });
-
-    it('claims nothing for zero units', async () => {
-        const key = uniqueKey();
-        expect(await claimCountedRateLimit(key, 1, WINDOW, 0)).toBe(0);
-        expect(await claimCountedRateLimit(key, 1, WINDOW, 1)).toBe(1);
-    });
-
-    it('fails open, admitting every unit, when the backend throws', async () => {
-        const redis = new RedisMock();
-        redis.multi = () => {
-            throw new Error('redis down');
-        };
-        configureRateLimit({ default: 'redis', redis });
-        const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-        expect(await claimCountedRateLimit(uniqueKey(), 1, WINDOW, 4)).toBe(4);
-        spy.mockRestore();
-    });
-
-    it('drops a memory counter once its windows have passed', async () => {
-        configureRateLimit();
-        vi.useFakeTimers({ toFake: ['Date'] });
-        windowStart(2_000);
-        const key = uniqueKey();
-        expect(await claimCountedRateLimit(key, 1, WINDOW, 1)).toBe(1);
-        windowStart(2_002);
-        sweepMemoryWindows();
-        windowStart(2_000);
-        expect(await claimCountedRateLimit(key, 1, WINDOW, 1)).toBe(1);
-    });
-});
-
 describe('claimRateLimit', () => {
    const uniqueKey = () => `claim-${Math.random().toString(36).slice(2, 10)}`;

@@ -290,26 +290,6 @@ describe('createRouteLifecycleMiddleware', () => {
        expect(after).toHaveLength(0);
    });

-    it('answers 429 when the vetoing listener asks for it', async () => {
-        const events = makeEvents();
-        events.on(`${BASE}.before` as never, (_k, data) => {
-            (data as RouteLifecycleEvent).allow = false;
-            (data as RouteLifecycleEvent).rejectReason = 'slow down';
-            (data as RouteLifecycleEvent).rejectStatus = 429;
-        });
-        const reject = record(events, `${BASE}.reject` as keyof EventMap);
-
-        const mw = createRouteLifecycleMiddleware(events, POST, PATH);
-        const res = new FakeRes();
-        await mw(makeReq('u-9'), res as unknown as Response, () => {});
-
-        expect(res.statusCode).toBe(429);
-        expect(res.body).toMatchObject({
-            error: { code: 'too_many_requests', message: 'slow down' },
-        });
-        expect(reject[0]).toMatchObject({ statusCode: 429 });
-    });
-
    it('treats a listener-sent response as a terminal after (not a reject) with the real status', async () => {
        const events = makeEvents();
        events.on(`${BASE}.before` as never, (_k, data) => {
@@ -20,7 +20,6 @@
 import type { Request, RequestHandler } from 'express';
 import { actorUid } from '../actor';
 import type { EventClient } from '../../clients/event/EventClient';
-import type { LifecycleRejectStatus } from '../../clients/event/types';
 import type { RouteMethod } from './types';

 type RoutePathValue = string | RegExp | Array<string | RegExp> | undefined;
@@ -101,33 +100,30 @@ export const createRouteLifecycleMiddleware = (
            ...base,
            allow: true as boolean,
            rejectReason: undefined as string | undefined,
-            rejectStatus: undefined as LifecycleRejectStatus | undefined,
        };
        if (observeBefore) {
            await events.emitAndWait(beforeKey, beforeEvent, {});
        }

        // Explicit veto: a listener set `allow = false`. Emit `reject` and
-        // answer 403 (or the listener's 429) — unless the listener already
-        // wrote its own response, in which case we report that status.
+        // answer 403 — unless the listener already wrote its own response, in
+        // which case we report that status rather than a misleading 403.
        if (beforeEvent.allow === false) {
-            const status = beforeEvent.rejectStatus === 429 ? 429 : 403;
            events.emit(
                `${keyBase}.reject`,
                {
                    phase: 'reject',
                    ...base,
-                    statusCode: res.headersSent ? res.statusCode : status,
+                    statusCode: res.headersSent ? res.statusCode : 403,
                    durationMs: Date.now() - startedAt,
                    rejectReason: beforeEvent.rejectReason,
                },
                {},
            );
            if (!res.headersSent) {
-                res.status(status).json({
+                res.status(403).json({
                    error: {
-                        code:
-                            status === 429 ? 'too_many_requests' : 'forbidden',
+                        code: 'forbidden',
                        message:
                            beforeEvent.rejectReason ?? 'Blocked by policy',
                    },
@@ -76,7 +76,6 @@ export type AccountGateUser = Partial<
        | 'phone'
        | 'card_fingerprint'
        | 'otp_enabled'
-        | 'metadata'
    >
 > & { id?: number };

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2024-present Puter Technologies Inc.
- *
- * This file is part of Puter.
- *
- * Puter is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-import { describe, expect, it } from 'vitest';
-import { isHttpError } from './http/HttpError.js';
-import {
-    SCHEDULE_LIST_LIMIT_CAP,
-    SCHEDULE_PEER_PATH,
-    schedulesUnavailable,
-} from './schedules.js';
-
-describe('schedules contract', () => {
-    it('answers an absent schedules service with a 503 events_disabled', () => {
-        const err = schedulesUnavailable();
-        expect(isHttpError(err)).toBe(true);
-        expect(err.statusCode).toBe(503);
-        expect(err.legacyCode).toBe('events_disabled');
-        // Expected on a server without schedules, so it must not page.
-        expect(err.noAlarm).toBe(true);
-    });
-
-    it('keeps the list cap and the peer path the extension relies on', () => {
-        expect(SCHEDULE_LIST_LIMIT_CAP).toBe(200);
-        expect(SCHEDULE_PEER_PATH).toBe('/broadcast/events/schedules');
-    });
-});
@@ -1,198 +0,0 @@
-/*
- * Copyright (C) 2024-present Puter Technologies Inc.
- *
- * This file is part of Puter.
- *
- * Puter is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-/**
- * What core asks of schedules. Nothing here is an implementation: an extension
- * registers `services.schedules`, and a server without one answers every
- * schedule route and `notify({ sendAt })` with `events_disabled`. Called by
- * extensions; keep these signatures stable.
- */
-
-import type { EventsDeployOutcome } from '../controllers/events/workerDeploy.js';
-import type { AppMessage } from '../services/notification/appMessage.js';
-import type { SuspendedReason } from '../stores/events/DurableSubscriptionStore.js';
-import type { DurableSubscription } from '../stores/events/types.js';
-import type { PageResult } from '../util/pagination.js';
-import type { Actor } from './actor.js';
-import { HttpError } from './http/HttpError.js';
-
-/** Why a schedule ended. */
-export type ScheduleEndReason =
-    | 'removed'
-    | 'ended'
-    | 'app_deleted'
-    | 'uninstalled'
-    | 'permission_revoked'
-    | 'holder_gone'
-    | 'app_gone'
-    | 'orphaned'
-    | 'delivered'
-    | 'dropped';
-
-/** What happened to a set of subscription rows schedules own. */
-export type ScheduleSubscriptionChange =
-    | {
-          type: 'suspended';
-          reason: SuspendedReason;
-          /** For a reason that never lifts; defaults to that reason. */
-          endReason?: ScheduleEndReason;
-      }
-    | { type: 'resumed' }
-    | { type: 'ended'; endReason: ScheduleEndReason };
-
-/** A schedule that keeps running, one that runs once, or a delayed notification. */
-export type ScheduleViewKind = 'recurring' | 'once' | 'deferred';
-
-/**
- * A schedule as its holder sees it. Times are epoch ms. `context` values are
- * never returned, as for a persistent subscription: only its keys and a hash.
- */
-export interface ScheduleView {
-    scheduleId: string;
-    kind: ScheduleViewKind;
-    appUid: string;
-    /** `null` once ended: the handler binding goes with the schedule. */
-    handlerName: string | null;
-    /** Set only when the handler lives in the holder's own scope. */
-    handlerScope?: 'user';
-    contextKeys: string[] | null;
-    contextHash: string | null;
-    /** Interval of an `every` schedule. */
-    every: number | null;
-    cron: string | null;
-    tz: string;
-    /** First allowed run; a one-shot's only run. */
-    startAt: number;
-    /** Last allowed run, inclusive. */
-    endsAt: number | null;
-    /** `sending` once a delayed send has started; it can't be cancelled then. */
-    state: 'active' | 'suspended' | 'sending' | 'ended';
-    suspendedReason: string | null;
-    endReason: string | null;
-    endedAt: number | null;
-    /**
-     * The slot it runs for next; `null` while suspended or sending, and once
-     * ended.
-     */
-    nextRunAt: number | null;
-    createdAt: number;
-}
-
-export interface ScheduleListRequest {
-    limit: number;
-    cursor?: string;
-    includeTotal: boolean;
-}
-
-/** The caps a holder's schedules are held to, from their plan. */
-export interface ScheduleQuota {
-    recurringPerUser: number;
-    recurringPerApp: number;
-    oneShotsPerUser: number;
-    oneShotsPerApp: number;
-    /** Worst-case runs per hour × 1000, summed over recurring rows. */
-    budgetPerUser: number;
-    budgetPerApp: number;
-}
-
-/** A caller cleared to supply `sendAt`, and when it asked for. */
-export interface DeferredSendPlan {
-    sendAt: number;
-    /** Due within 5 seconds, or past: sent now rather than stored. */
-    immediate: boolean;
-    holderUserId: number;
-    appUid: string;
-    handlerDepth: number;
-    quota: ScheduleQuota;
-}
-
-/** What a delayed app message stores until it is sent. */
-export interface DeferredAppMessage {
-    message: AppMessage;
-    /** A KV share handle naming the recipient. */
-    to?: string;
-}
-
-/**
- * A condition on one row of another table that statements embed as `EXISTS
- * (SELECT 1 FROM <table> WHERE <where>)`, binding `values`.
- */
-export interface SqlGuard {
-    table: string;
-    where: string;
-    values: unknown[];
-}
-
-/** Ceiling of a schedule listing page. */
-export const SCHEDULE_LIST_LIMIT_CAP = 200;
-
-/** The signed peer route a region's schedule changes are sent to. */
-export const SCHEDULE_PEER_PATH = '/broadcast/events/schedules';
-
-export const schedulesUnavailable = (): HttpError =>
-    new HttpError(503, 'Schedules are not available on this server', {
-        legacyCode: 'events_disabled',
-        // The designed answer of a server without schedules, not a fault.
-        noAlarm: true,
-    });
-
-export interface ScheduleServiceContract {
-    /**
-     * Keep schedules in step with a change to the subscription rows they own.
-     * Never throws: the subscription change has already happened.
-     */
-    onSubscriptionsChanged(
-        rows: readonly DurableSubscription[],
-        change: ScheduleSubscriptionChange,
-    ): Promise<void>;
-    createFor(
-        actor: Actor,
-        body: Record<string, unknown>,
-    ): Promise<ScheduleView>;
-    list(
-        actor: Actor,
-        request: ScheduleListRequest,
-    ): Promise<PageResult<ScheduleView>>;
-    get(actor: Actor, scheduleId: unknown): Promise<ScheduleView>;
-    update(
-        actor: Actor,
-        scheduleId: unknown,
-        changes: unknown,
-    ): Promise<ScheduleView>;
-    remove(actor: Actor, scheduleId: unknown): Promise<void>;
-    /** `results`: each change's index outcome, in order (`null` if dropped). */
-    receivePeerChanges(
-        body: unknown,
-    ): Promise<{ applied: number; results?: Array<number | null> }>;
-    /** Checks a caller supplying `sendAt`; `events_disabled` when off. */
-    prepareSendAt(actor: Actor, sendAt: unknown): Promise<DeferredSendPlan>;
-    createDeferredAppMessage(
-        plan: DeferredSendPlan,
-        message: DeferredAppMessage,
-    ): Promise<{ scheduleId: string; sendAt: number }>;
-    /**
-     * Runs an events worker deploy under the schedules' deploy gate; `capped`
-     * for a schedule run's. A passthrough when schedules are off.
-     */
-    gateDeploy?(
-        script: string,
-        options: { capped: boolean },
-        deploy: () => Promise<EventsDeployOutcome>,
-    ): Promise<EventsDeployOutcome>;
-}
@@ -209,7 +209,6 @@ afterAll(async () => {
 const attemptsFor = async (
    model: string,
    thrown: unknown = new Error('upstream down'),
-    extra: { provider?: string; fallback?: boolean } = {},
 ) => {
    createMock.mockRejectedValue(thrown);
    let caught: HttpError | undefined;
@@ -218,7 +217,6 @@ const attemptsFor = async (
            driver.complete({
                model,
                messages: [{ role: 'user', content: 'hi' }],
-                ...extra,
            }),
        );
    } catch (e) {
@@ -888,59 +886,6 @@ describe('ChatCompletionDriver duplicate-model fallback', () => {
    });
 });

-describe('ChatCompletionDriver fallback opt-out', () => {
-    const SHARED = 'deepseek-v4-pro';
-
-    it('fails on the first route when the caller sets fallback: false', async () => {
-        const attempts = await attemptsFor(SHARED, undefined, {
-            fallback: false,
-        });
-
-        expect(attempts).toHaveLength(1);
-        expect(attempts[0]).toMatchObject({ provider: 'deepseek' });
-    });
-
-    it('tries only the pinned provider', async () => {
-        const attempts = await attemptsFor(SHARED, undefined, {
-            provider: 'openrouter',
-            fallback: false,
-        });
-
-        expect(attempts).toHaveLength(1);
-        expect(attempts[0]).toMatchObject({ provider: 'openrouter' });
-    });
-
-    it('rejects a pinned provider that has no route for the model', async () => {
-        createMock.mockClear();
-        await expect(
-            withTestActor(() =>
-                driver.complete({
-                    model: SHARED,
-                    provider: 'claude',
-                    fallback: false,
-                    messages: [{ role: 'user', content: 'hi' }],
-                }),
-            ),
-        ).rejects.toMatchObject({ statusCode: 400 });
-        expect(createMock).not.toHaveBeenCalled();
-    });
-
-    it('still marks the failed route for the next caller', async () => {
-        const [only] = await attemptsFor(SHARED, undefined, {
-            fallback: false,
-        });
-
-        expect(isRouteUnhealthy(only.provider, only.model)).toBe(true);
-    });
-
-    it('keeps the chain when fallback is true or unset', async () => {
-        expect(
-            await attemptsFor(SHARED, undefined, { fallback: true }),
-        ).toHaveLength(3);
-        expect(await attemptsFor(SHARED)).toHaveLength(3);
-    });
-});
-
 // Each attempt in a fallback chain is a whole completion at that model's
 // prices, so each one has to clear the credit gate on its own. The chain used
 // to re-check with a nominal 1-microcent amount, which any account with a
@@ -709,20 +709,6 @@ export class ChatCompletionDriver extends PuterDriver {
                legacyCode: 'bad_request',
            });
        }
-        // A pinned provider without a route for the model normally resolves
-        // to another vendor; with `fallback: false` that is the one thing the
-        // caller asked us not to do.
-        if (
-            args.fallback === false &&
-            intendedProvider &&
-            model.provider !== intendedProvider
-        ) {
-            throw new HttpError(
-                400,
-                `Model ${args.model} is not served by provider ${intendedProvider}`,
-                { legacyCode: 'bad_request' },
-            );
-        }

        args.messages = normalizeMediaParts(normalize_messages(args.messages));
        if (args.tools) {
@@ -960,15 +946,8 @@ export class ChatCompletionDriver extends PuterDriver {
            const bucketKey = model.id;
            const tried = new Set([routeId(model.provider!, model.id)]);
            let lastError: Error | null = e as Error;
-            // With `fallback: false` the caller wants this route's answer or
-            // its error, not a bill for another provider's attempt.
-            const fallbackAllowed = args.fallback !== false;

-            while (
-                fallbackAllowed &&
-                lastError &&
-                attempts.length < MAX_ATTEMPTS
-            ) {
+            while (lastError && attempts.length < MAX_ATTEMPTS) {
                const fallback = this.#findFallback(bucketKey, tried);
                if (!fallback) break;

@@ -809,11 +809,6 @@ describe('Alibaba official catalog', () => {
        expect(models.some((model) => model.id === 'qwen-image-fixture')).toBe(
            false,
        );
-        const fixture = models.find(
-            (model) => model.id === 'qwen-catalog-fixture',
-        )!;
-        expect(fixture.puterId).toBe('alibaba:qwen/qwen-catalog-fixture');
-        expect(modelLookupNames(models)).toContain('qwen-catalog-fixture');
        const plus = models.find((model) => model.id === 'qwen-plus')!;
        const original = ALIBABA_MODELS.find(
            (model) => model.id === 'qwen-plus',
@@ -914,115 +909,6 @@ describe('Alibaba official catalog', () => {
        expect(model.costs).toEqual({ tokens: 1_000_000 });
    });

-    it.each([
-        ['qwen3.9-plus-2027-01-01', 'alibaba:qwen/qwen3.9-plus-2027-01-01'],
-        ['kimi/kimi-k3', 'alibaba:kimi/kimi-k3'],
-        [
-            'deepseek-v4.1-flash-1017',
-            'alibaba:deepseek/deepseek-v4.1-flash-1017',
-        ],
-        ['glm-5.3-prime', 'alibaba:zhipu/glm-5.3-prime'],
-        ['decision-model-preview', 'alibaba:qwen/decision-model-preview'],
-    ])(
-        'gives uncurated model %s a puterId in the alibaba:<vendor>/<id> form',
-        (id, puterId) => {
-            const model = mapAlibabaCatalogModel({
-                model: id,
-                capabilities: ['TG'],
-            })!;
-            expect(model.puterId).toBe(puterId);
-        },
-    );
-
-    it('skips a vendor-prefixed spelling of a curated model', () => {
-        const model = mapAlibabaCatalogModel({
-            model: 'zhipu/glm-5.2',
-            capabilities: ['TG', 'Reasoning'],
-            inference_metadata: {
-                request_modality: ['Text'],
-                response_modality: ['Text'],
-            },
-        });
-        expect(model).toBeNull();
-    });
-
-    it.each([
-        [
-            'ASR',
-            {
-                capabilities: ['ASR'],
-                inference_metadata: {
-                    request_modality: ['Audio'],
-                    response_modality: ['Text'],
-                },
-            },
-        ],
-        [
-            'rerank',
-            {
-                capabilities: ['TR'],
-                inference_metadata: {
-                    request_modality: ['Text'],
-                    response_modality: ['Text'],
-                },
-            },
-        ],
-        [
-            'image generation',
-            {
-                capabilities: ['IG'],
-                inference_metadata: {
-                    request_modality: ['Text'],
-                    response_modality: ['Text', 'Image'],
-                },
-            },
-        ],
-        [
-            'realtime omni',
-            {
-                capabilities: ['Realtime-Omni'],
-                inference_metadata: {
-                    request_modality: ['Text', 'Image', 'Audio', 'Video'],
-                    response_modality: ['Text', 'Audio'],
-                },
-            },
-        ],
-        [
-            'TTS',
-            {
-                capabilities: ['TTS'],
-                inference_metadata: {
-                    request_modality: ['Audio'],
-                    response_modality: ['Text'],
-                },
-            },
-        ],
-    ])('rejects %s models that cannot serve chat completions', (_kind, raw) => {
-        expect(
-            mapAlibabaCatalogModel({
-                model: 'non-chat-fixture',
-                ...(raw as AlibabaApiModel),
-            }),
-        ).toBeNull();
-    });
-
-    it('admits a vision model', () => {
-        const model = mapAlibabaCatalogModel({
-            model: 'vision-fixture',
-            capabilities: ['VU'],
-            inference_metadata: {
-                request_modality: ['Text', 'Image'],
-                response_modality: ['Text'],
-            },
-        })!;
-        expect(model.modalities?.input).toEqual(['text', 'image']);
-    });
-
-    it('does not admit an uncurated entry without capability or modality data', () => {
-        expect(mapAlibabaCatalogModel({ model: 'mystery-model' })).toBeNull();
-        expect(mapAlibabaCatalogModel({ model: 'qwen-plus' })).not.toBeNull();
-    });
-
    it('refuses inference with unverified catalog prices', async () => {
        seedPages();
        const { provider } = makeProvider();
@@ -82,23 +82,6 @@ const positiveLimit = (value: unknown): number | undefined =>
        ? value
        : undefined;

-const chatCapabilities = ['TG', 'Reasoning', 'VU'];
-
-const curatedPuterIds = new Set(ALIBABA_MODELS.map((model) => model.puterId));
-
-const inferPuterId = (id: string): string => {
-    if (id.includes('/')) return `alibaba:${id}`;
-    const family = id.split('-')[0];
-    const sibling = ALIBABA_MODELS.find(
-        (model) => model.puterId && model.id.split('-')[0] === family,
-    );
-    // Unprefixed feed ids are Model Studio's own family unless a curated
-    // sibling points at a third-party org.
-    const org =
-        sibling?.puterId?.slice('alibaba:'.length).split('/')[0] ?? 'qwen';
-    return `alibaba:${org}/${id}`;
-};
-
 export const mapAlibabaCatalogModel = (
    raw: AlibabaApiModel,
    previous?: IChatModel,
@@ -107,25 +90,16 @@ export const mapAlibabaCatalogModel = (
    const id = raw.model.trim();
    const existing =
        previous ?? ALIBABA_MODELS.find((model) => model.id === id);
-    const input = raw.inference_metadata?.request_modality;
    const output = raw.inference_metadata?.response_modality;
+    if (output && !output.includes('Text')) return null;
    if (
-        raw.capabilities &&
-        !raw.capabilities.some((capability) =>
-            chatCapabilities.includes(capability),
+        !output &&
+        !existing &&
+        !raw.capabilities?.some((capability) =>
+            ['TG', 'Reasoning', 'VU'].includes(capability),
        )
    )
        return null;
-    if (input && !input.includes('Text')) return null;
-    if (output && !output.includes('Text')) return null;
-    if (!raw.capabilities && !input && !output && !existing) return null;
-    let puterId = existing?.puterId;
-    if (!puterId) {
-        puterId = inferPuterId(id);
-        // A feed entry spelling a curated model differently would duplicate
-        // the curated entry's puterId and list the model twice.
-        if (curatedPuterIds.has(puterId)) return null;
-    }
    const catalogPricing: AlibabaCatalogTier[] = (raw.prices ?? []).map(
        (tier) => {
            // Abbreviated ranges do not specify whether k means 1000 or 1024 tokens.
@@ -175,7 +149,6 @@ export const mapAlibabaCatalogModel = (
    return {
        ...existing,
        id,
-        puterId,
        name: raw.name ?? existing?.name ?? id,
        description: raw.description ?? existing?.description,
        aliases: existing?.aliases,
@@ -449,22 +449,6 @@ describe('AzureResponsesProvider.complete request shape', () => {
        expect(args.service_tier).toBe('default');
    });

-    it('sends the wire spelling of the in-memory cache retention', async () => {
-        const provider = makeProvider();
-        responsesCreateMock.mockResolvedValueOnce(okResponse);
-
-        await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-5.3-codex',
-                messages: [{ role: 'user', content: 'hi' }],
-                prompt_cache_retention: 'in-memory',
-            } as never),
-        );
-
-        const [args] = responsesCreateMock.mock.calls[0]!;
-        expect(args.prompt_cache_retention).toBe('in_memory');
-    });
-
    it.each([
        ['previous_response_id', 'resp_1'],
        ['conversation', 'conv_1'],
@@ -35,7 +35,6 @@ import * as OpenAiUtil from '../../utils/OpenAIUtil.js';
 import {
    clampReasoningEffort,
    openAICompatParams,
-    promptCacheRetentionToWire,
    rejectStatefulResponsesFields,
 } from '../../utils/openaiParams.js';
 import { buildCostsOverride } from '../../utils/pricing.js';
@@ -210,9 +209,6 @@ export class AzureResponsesProvider implements IChatProvider {
        const userIdentifier = upstreamUserIdentifier(actor);
        // Cache key defaults to the actor identifier; see upstreamUserIdentifier.
        const cacheKey = prompt_cache_key ?? userIdentifier;
-        const cacheRetention = promptCacheRetentionToWire(
-            prompt_cache_retention,
-        );

        // Resolve any `puter_path` content parts into inline base64 data URLs
        // before the Responses API sees them.
@@ -311,8 +307,8 @@ export class AzureResponsesProvider implements IChatProvider {
            ...(instructions !== undefined ? { instructions } : {}),
            ...(metadata !== undefined ? { metadata } : {}),
            ...(cacheKey !== undefined ? { prompt_cache_key: cacheKey } : {}),
-            ...(cacheRetention !== undefined
-                ? { prompt_cache_retention: cacheRetention }
+            ...(prompt_cache_retention !== undefined
+                ? { prompt_cache_retention }
                : {}),
            ...(store !== undefined ? { store } : {}),
            ...(max_tokens !== undefined
@@ -23,7 +23,6 @@ import { HttpError } from '../../../../core/http/HttpError.js';
 import type { MeteringService } from '../../../../services/metering/MeteringService.js';
 import { upstreamUserIdentifier } from '../../../util/upstreamIdentifier.js';
 import type { IChatModel, ICompleteArguments } from '../../types.js';
-import { promptCacheRetentionToWire } from '../../utils/openaiParams.js';
 import { sdkClientOptions } from '../../utils/sdkClient.js';
 import {
    type ChatProviderConfig,
@@ -108,9 +107,12 @@ export class MetaProvider extends OpenAICompatProvider {
                ? requestedEffort
                : undefined;

-        const cacheRetention = promptCacheRetentionToWire(
-            args.prompt_cache_retention,
-        );
+        // Puter spells the in-memory retention with a hyphen; Meta's enum
+        // uses an underscore.
+        const cacheRetention =
+            args.prompt_cache_retention === 'in-memory'
+                ? 'in_memory'
+                : args.prompt_cache_retention;

        // The identifier is Puter's abuse attribution, so `custom` can't
        // override it. Cache key defaults to it; see upstreamUserIdentifier.
@@ -249,130 +249,6 @@ describe('OpenAiChatProvider.complete argument validation', () => {
        expect(result).toEqual({ delegated: true });
    });

-    it('delegates a 12h cache lifetime to the Responses provider, which is the only API that writes it', async () => {
-        const { provider } = makeProvider();
-        const sibling = {
-            complete: vi.fn().mockResolvedValue({ delegated: true }),
-        };
-        provider.setResponsesProvider(
-            sibling as unknown as Parameters<
-                typeof provider.setResponsesProvider
-            >[0],
-        );
-
-        const params = {
-            model: 'gpt-6-luna',
-            messages: [{ role: 'user', content: 'hi' }],
-            prompt_cache_options: { ttl: '12h' as const },
-        };
-        const result = await withTestActor(() => provider.complete(params));
-
-        expect(createMock).not.toHaveBeenCalled();
-        expect(sibling.complete).toHaveBeenCalledWith(params);
-        expect(result).toEqual({ delegated: true });
-    });
-
-    it.each([
-        ['30m', { mode: 'explicit', ttl: '30m' }],
-        ['12h', { mode: 'explicit', ttl: '12h' }],
-    ])(
-        'delegates a %s breakpoint lifetime to the Responses provider, since Chat Completions rejects the field',
-        async (_ttl, breakpoint) => {
-            const { provider } = makeProvider();
-            const sibling = {
-                complete: vi.fn().mockResolvedValue({ delegated: true }),
-            };
-            provider.setResponsesProvider(
-                sibling as unknown as Parameters<
-                    typeof provider.setResponsesProvider
-                >[0],
-            );
-
-            const params = {
-                model: 'gpt-6-luna',
-                messages: [
-                    {
-                        role: 'system',
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'long prefix',
-                                prompt_cache_breakpoint: breakpoint,
-                            },
-                        ],
-                    },
-                    { role: 'user', content: 'hi' },
-                ],
-            };
-            const result = await withTestActor(() =>
-                provider.complete(params as never),
-            );
-
-            expect(createMock).not.toHaveBeenCalled();
-            expect(sibling.complete).toHaveBeenCalledWith(params);
-            expect(result).toEqual({ delegated: true });
-        },
-    );
-
-    it('keeps a breakpoint without a lifetime on the Chat Completions path, intact', async () => {
-        const { provider } = makeProvider();
-        createMock.mockResolvedValueOnce({
-            choices: [
-                {
-                    message: { content: 'ok', role: 'assistant' },
-                    finish_reason: 'stop',
-                },
-            ],
-            usage: { prompt_tokens: 1, completion_tokens: 1 },
-        });
-
-        await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-6-luna',
-                messages: [
-                    {
-                        role: 'system',
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'long prefix',
-                                prompt_cache_breakpoint: { mode: 'explicit' },
-                            },
-                        ],
-                    },
-                    { role: 'user', content: 'hi' },
-                ],
-            } as never),
-        );
-
-        const [args] = createMock.mock.calls[0]!;
-        expect(args.messages[0]).toMatchObject({
-            role: 'system',
-            content: [
-                {
-                    type: 'text',
-                    text: 'long prefix',
-                    prompt_cache_breakpoint: { mode: 'explicit' },
-                },
-            ],
-        });
-    });
-
-    it('throws 400 for a 12h cache lifetime without a Responses sibling provider', async () => {
-        const { provider } = makeProvider();
-
-        await expect(
-            withTestActor(() =>
-                provider.complete({
-                    model: 'gpt-6-luna',
-                    messages: [{ role: 'user', content: 'hi' }],
-                    prompt_cache_options: { ttl: '12h' },
-                }),
-            ),
-        ).rejects.toMatchObject({ statusCode: 400 });
-        expect(createMock).not.toHaveBeenCalled();
-    });
-
    it('requestPricing delegates to the Responses sibling (web_search\'s own hold), and no-ops without one', async () => {
        const { provider } = makeProvider();
        const args = {
@@ -473,31 +349,6 @@ describe('OpenAiChatProvider.complete request shape', () => {
        expect(args.safety_identifier).toBe('puter-u42');
    });

-    it('forwards 30m prompt_cache_options and the wire spelling of prompt_cache_retention', async () => {
-        const { provider } = makeProvider();
-        createMock.mockResolvedValueOnce(baseCompletion);
-
-        await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-6-luna',
-                messages: [{ role: 'user', content: 'hello' }],
-                prompt_cache_retention: 'in-memory',
-                prompt_cache_options: {
-                    mode: 'explicit',
-                    ttl: '30m',
-                    prewarm: true,
-                } as never,
-            }),
-        );
-
-        const [args] = createMock.mock.calls[0]!;
-        expect(args.prompt_cache_retention).toBe('in_memory');
-        expect(args.prompt_cache_options).toEqual({
-            mode: 'explicit',
-            ttl: '30m',
-        });
-    });
-
    it.each([
        'gpt-6-astra',
        'gpt-6.1-sol',
@@ -814,7 +665,7 @@ describe('OpenAiChatProvider.complete non-stream output', () => {
            },
        });

-        const result = await withTestActor(() =>
+        await withTestActor(() =>
            provider.complete({
                model: 'gpt-6-luna',
                messages: [{ role: 'user', content: 'hi' }],
@@ -834,13 +685,6 @@ describe('OpenAiChatProvider.complete non-stream output', () => {
            cached_tokens: 1000 * Number(luna.costs.cached_tokens),
            cache_write_tokens: 3000 * Number(luna.costs.cache_write_tokens),
        });
-        // Chat Completions only writes OpenAI's default 30m entries.
-        expect((result as { usageDetails: unknown }).usageDetails).toEqual({
-            inputTokens: 1000,
-            outputTokens: 12,
-            cacheReadTokens: 1000,
-            cacheWrite30mTokens: 3000,
-        });
    });

    it('zeroes cached_tokens when prompt_tokens_details is missing', async () => {
@@ -35,10 +35,7 @@ import { make_openai_tools } from '../../utils/FunctionCalling.js';
 import * as OpenAiUtil from '../../utils/OpenAIUtil.js';
 import {
    clampReasoningEffort,
-    messagesHaveCacheBreakpointTtl,
    openAICompatParams,
-    promptCacheOptionsToWire,
-    promptCacheRetentionToWire,
 } from '../../utils/openaiParams.js';
 import { OPEN_AI_MODELS } from './models.js';
 import type { OpenAiResponsesChatProvider } from './OpenAiChatResponsesProvider.js';
@@ -129,11 +126,8 @@ export class OpenAiChatProvider implements IChatProvider {
            temperature,
            text,
            prompt_cache_key,
-            prompt_cache_retention,
-            prompt_cache_options,
        } = params;
        let { messages, model } = params;
-        const cacheOptions = promptCacheOptionsToWire(prompt_cache_options);
        if (
            tools?.filter((e) => isWebSearchTool(e as Record<string, unknown>))
                .length
@@ -163,21 +157,6 @@ export class OpenAiChatProvider implements IChatProvider {
            }
            return await this.#responsesProvider.complete(params);
        }
-        // Only the Responses API writes 12h cache entries or takes a lifetime
-        // on a `prompt_cache_breakpoint`; Chat Completions rejects both.
-        if (
-            cacheOptions?.ttl === '12h' ||
-            messagesHaveCacheBreakpointTtl(messages)
-        ) {
-            if (!this.#responsesProvider) {
-                throw new HttpError(
-                    400,
-                    'a prompt cache lifetime requires the OpenAI Responses provider, which is not configured',
-                    { legacyCode: 'bad_request' },
-                );
-            }
-            return await this.#responsesProvider.complete(params);
-        }
        // Validate messages
        if (!Array.isArray(messages)) {
            throw new HttpError(400, '`messages` must be an array', {
@@ -201,9 +180,6 @@ export class OpenAiChatProvider implements IChatProvider {
        const userIdentifier = upstreamUserIdentifier(actor);
        // Cache key defaults to the actor identifier; see upstreamUserIdentifier.
        const cacheKey = prompt_cache_key ?? userIdentifier;
-        const cacheRetention = promptCacheRetentionToWire(
-            prompt_cache_retention,
-        );

        // Strip Anthropic-only shape a fallback-replayed message can carry
        // (thinking/server-tool blocks, cache_control, citations) before the
@@ -240,12 +216,6 @@ export class OpenAiChatProvider implements IChatProvider {
            user: userIdentifier,
            safety_identifier: userIdentifier,
            ...(cacheKey !== undefined ? { prompt_cache_key: cacheKey } : {}),
-            ...(cacheRetention !== undefined
-                ? { prompt_cache_retention: cacheRetention }
-                : {}),
-            ...(cacheOptions !== undefined
-                ? { prompt_cache_options: cacheOptions }
-                : {}),
            messages: messages,
            model: modelUsed.id,
            ...(mappedTools?.length ? { tools: mappedTools } : {}),
@@ -284,11 +254,28 @@ export class OpenAiChatProvider implements IChatProvider {
        );

        return OpenAiUtil.handle_completion_output({
-            usage_calculator: ({ usage, setUsageCosts, setUsageDetails }) => {
-                // GPT-5.6 and later report cache writes inside
-                // `prompt_tokens`, like cached reads; Chat Completions only
-                // writes the default 30m entries, billed at 1.25x input.
-                const trackedUsage = OpenAiUtil.splitCachedPrompt(usage);
+            usage_calculator: ({ usage, setUsageCosts }) => {
+                const cachedTokens =
+                    usage.prompt_tokens_details?.cached_tokens ?? 0;
+                // GPT-5.6 and later bill cache writes at 1.25x input. They're
+                // reported inside `prompt_tokens`, like cached reads.
+                // The SDK doesn't type `cache_write_tokens` yet.
+                const cacheWriteTokens =
+                    (
+                        usage.prompt_tokens_details as
+                            { cache_write_tokens?: number } | undefined
+                    )?.cache_write_tokens ?? 0;
+                const trackedUsage = {
+                    prompt_tokens:
+                        (usage.prompt_tokens ?? 0) -
+                        cachedTokens -
+                        cacheWriteTokens,
+                    completion_tokens: usage.completion_tokens ?? 0,
+                    cached_tokens: cachedTokens,
+                    ...(cacheWriteTokens
+                        ? { cache_write_tokens: cacheWriteTokens }
+                        : {}),
+                };

                const metered = meterChatUsage(
                    this.#meteringService,
@@ -298,11 +285,6 @@ export class OpenAiChatProvider implements IChatProvider {
                    trackedUsage,
                );
                setUsageCosts(metered.costs);
-                setUsageDetails(
-                    OpenAiUtil.usageDetailsFromTrackedUsage(metered.usage, {
-                        writeTtl: '30m',
-                    })!,
-                );
                return metered.usage;
            },
            stream,
@@ -246,7 +246,6 @@ describe('OpenAiResponsesChatProvider model catalog', () => {
                    prompt_tokens: input,
                    cached_tokens: cached,
                    cache_write_tokens: input * 1.25,
-                    cache_write_12h_tokens: input * 2.5,
                    completion_tokens: output,
                },
                context: 1_050_000,
@@ -845,7 +844,7 @@ describe('OpenAiResponsesChatProvider.complete non-stream output', () => {
            },
        });

-        const result = await withTestActor(() =>
+        await withTestActor(() =>
            provider.complete({
                model: 'gpt-6-luna',
                messages: [{ role: 'user', content: 'hi' }],
@@ -868,115 +867,6 @@ describe('OpenAiResponsesChatProvider.complete non-stream output', () => {
            cached_tokens: 1000 * Number(luna.costs.cached_tokens),
            cache_write_tokens: 3000 * Number(luna.costs.cache_write_tokens),
        });
-        // Writes without a per-lifetime breakdown are OpenAI's default 30m
-        // entries, and the neutral breakdown says so.
-        expect((result as { usageDetails: unknown }).usageDetails).toEqual({
-            inputTokens: 1000,
-            outputTokens: 20,
-            cacheReadTokens: 1000,
-            cacheWrite30mTokens: 3000,
-        });
-    });
-
-    it('bills 12h cache writes at 2.5x input and the other writes at 1.25x', async () => {
-        const luna = OPEN_AI_MODELS.find((m) => m.id === 'gpt-6-luna')!;
-        const { provider } = makeProvider();
-        // One request can write both lifetimes: an explicit 12h breakpoint
-        // plus the implicit 30m one OpenAI adds at the end of the prompt.
-        responsesCreateMock.mockResolvedValueOnce({
-            output: [{ role: 'assistant' }],
-            output_text: 'ok',
-            usage: {
-                input_tokens: 6026,
-                output_tokens: 5,
-                input_tokens_details: {
-                    cached_tokens: 0,
-                    cache_write_tokens: 6023,
-                    cache_write_tokens_details: {
-                        ttl_12h_tokens: 6012,
-                        ttl_30m_tokens: 11,
-                    },
-                },
-            },
-        });
-
-        const result = await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-6-luna',
-                messages: [{ role: 'user', content: 'hi' }],
-                prompt_cache_options: { ttl: '12h' },
-            }),
-        );
-
-        const [usage, , , overrides] = recordSpy.mock.calls[0]!;
-        expect(usage).toEqual({
-            prompt_tokens: 3,
-            completion_tokens: 5,
-            cached_tokens: 0,
-            cache_write_tokens: 11,
-            cache_write_12h_tokens: 6012,
-        });
-        expect(luna.costs.cache_write_12h_tokens).toBe(
-            Number(luna.costs.prompt_tokens) * 2.5,
-        );
-        expect(overrides).toEqual({
-            prompt_tokens: 3 * Number(luna.costs.prompt_tokens),
-            completion_tokens: 5 * Number(luna.costs.completion_tokens),
-            cached_tokens: 0,
-            cache_write_tokens: 11 * Number(luna.costs.cache_write_tokens),
-            cache_write_12h_tokens:
-                6012 * Number(luna.costs.cache_write_12h_tokens),
-        });
-        expect((result as { usageDetails: unknown }).usageDetails).toEqual({
-            inputTokens: 3,
-            outputTokens: 5,
-            cacheWrite30mTokens: 11,
-            cacheWrite12hTokens: 6012,
-        });
-    });
-
-    it('forwards prompt_cache_options and the wire spelling of prompt_cache_retention', async () => {
-        const { provider } = makeProvider();
-        responsesCreateMock.mockResolvedValueOnce({
-            output: [{ role: 'assistant' }],
-            output_text: 'ok',
-            usage: { input_tokens: 1, output_tokens: 1 },
-        });
-
-        await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-6-luna',
-                messages: [{ role: 'user', content: 'hi' }],
-                prompt_cache_retention: 'in-memory',
-                prompt_cache_options: {
-                    mode: 'explicit',
-                    ttl: '12h',
-                    comparison_response_id: 'resp_1',
-                } as never,
-            }),
-        );
-
-        const [args] = responsesCreateMock.mock.calls[0]!;
-        expect(args.prompt_cache_retention).toBe('in_memory');
-        expect(args.prompt_cache_options).toEqual({
-            mode: 'explicit',
-            ttl: '12h',
-        });
-    });
-
-    it('rejects a cache lifetime OpenAI does not offer before calling upstream', async () => {
-        const { provider } = makeProvider();
-
-        await expect(
-            withTestActor(() =>
-                provider.complete({
-                    model: 'gpt-6-luna',
-                    messages: [{ role: 'user', content: 'hi' }],
-                    prompt_cache_options: { ttl: '2h' } as never,
-                }),
-            ),
-        ).rejects.toMatchObject({ statusCode: 400 });
-        expect(responsesCreateMock).not.toHaveBeenCalled();
    });

    it.each([
@@ -1178,69 +1068,6 @@ describe('OpenAiResponsesChatProvider.complete streaming', () => {
        });
    });

-    it('labels streamed cache writes by lifetime on the final usage chunk', async () => {
-        const luna = OPEN_AI_MODELS.find((m) => m.id === 'gpt-6-luna')!;
-        const { provider } = makeProvider();
-        responsesCreateMock.mockReturnValueOnce(
-            asAsyncIterable([
-                { type: 'response.output_text.delta', delta: 'ok' },
-                {
-                    type: 'response.completed',
-                    response: {
-                        usage: {
-                            input_tokens: 6026,
-                            output_tokens: 5,
-                            input_tokens_details: {
-                                cached_tokens: 0,
-                                cache_write_tokens: 6023,
-                                cache_write_tokens_details: {
-                                    ttl_12h_tokens: 6012,
-                                    ttl_30m_tokens: 11,
-                                },
-                            },
-                        },
-                    },
-                },
-            ]),
-        );
-
-        const result = await withTestActor(() =>
-            provider.complete({
-                model: 'gpt-6-luna',
-                messages: [{ role: 'user', content: 'say ok' }],
-                stream: true,
-                prompt_cache_options: { ttl: '12h' },
-            }),
-        );
-        const harness = makeCapturingChatStream();
-        await (
-            result as {
-                init_chat_stream: (p: { chatStream: unknown }) => Promise<void>;
-            }
-        ).init_chat_stream({ chatStream: harness.chatStream });
-
-        const usageEvent = harness.events().find((e) => e.type === 'usage');
-        expect(usageEvent?.usage).toEqual({
-            prompt_tokens: 3,
-            completion_tokens: 5,
-            cached_tokens: 0,
-            cache_write_tokens: 11,
-            cache_write_12h_tokens: 6012,
-        });
-        expect(usageEvent?.usageDetails).toEqual({
-            inputTokens: 3,
-            outputTokens: 5,
-            cacheWrite30mTokens: 11,
-            cacheWrite12hTokens: 6012,
-        });
-        const [, , , overrides] = recordSpy.mock.calls[0]!;
-        expect(overrides).toMatchObject({
-            cache_write_tokens: 11 * Number(luna.costs.cache_write_tokens),
-            cache_write_12h_tokens:
-                6012 * Number(luna.costs.cache_write_12h_tokens),
-        });
-    });
-
    it('emits a tool_use block when response.output_item.done arrives with a function_call', async () => {
        const { provider } = makeProvider();
        responsesCreateMock.mockReturnValueOnce(
@@ -32,8 +32,6 @@ import * as OpenAiUtil from '../../utils/OpenAIUtil.js';
 import {
    clampReasoningEffort,
    openAICompatParams,
-    promptCacheOptionsToWire,
-    promptCacheRetentionToWire,
    rejectStatefulResponsesFields,
 } from '../../utils/openaiParams.js';
 import { responseSamplingParams } from '../../utils/responseSampling.js';
@@ -152,7 +150,6 @@ export class OpenAiResponsesChatProvider implements IChatProvider {
        prompt,
        prompt_cache_key,
        prompt_cache_retention,
-        prompt_cache_options,
        store,
        top_p,
        truncation,
@@ -198,10 +195,6 @@ export class OpenAiResponsesChatProvider implements IChatProvider {
        const userIdentifier = upstreamUserIdentifier(actor);
        // Cache key defaults to the actor identifier; see upstreamUserIdentifier.
        const cacheKey = prompt_cache_key ?? userIdentifier;
-        const cacheRetention = promptCacheRetentionToWire(
-            prompt_cache_retention,
-        );
-        const cacheOptions = promptCacheOptionsToWire(prompt_cache_options);

        if (tools) {
            // Unravel tools to OpenAI Responses API format
@@ -295,11 +288,8 @@ export class OpenAiResponsesChatProvider implements IChatProvider {
            ...(instructions !== undefined ? { instructions } : {}),
            ...(metadata !== undefined ? { metadata } : {}),
            ...(cacheKey !== undefined ? { prompt_cache_key: cacheKey } : {}),
-            ...(cacheRetention !== undefined
-                ? { prompt_cache_retention: cacheRetention }
-                : {}),
-            ...(cacheOptions !== undefined
-                ? { prompt_cache_options: cacheOptions }
+            ...(prompt_cache_retention !== undefined
+                ? { prompt_cache_retention }
                : {}),
            ...(store !== undefined ? { store } : {}),
            ...(max_tokens !== undefined
@@ -320,17 +310,24 @@ export class OpenAiResponsesChatProvider implements IChatProvider {
            { signal: Context.get('upstreamSignal') },
        );
        return OpenAiUtil.handle_completion_output_responses_api({
-            usage_calculator: ({
-                usage,
-                webSearchCalls,
-                setUsageCosts,
-                setUsageDetails,
-            }) => {
-                // GPT-5.6 and later report cache writes inside `input_tokens`,
-                // like cached reads, split by lifetime (30m and 12h entries
-                // cost 1.25x and 2.5x input to write).
+            usage_calculator: ({ usage, webSearchCalls, setUsageCosts }) => {
+                const cachedTokens =
+                    (usage as any).input_tokens_details?.cached_tokens ?? 0;
+                // GPT-5.6 and later bill cache writes at 1.25x input. They're
+                // reported inside `input_tokens`, like cached reads.
+                const cacheWriteTokens =
+                    (usage as any).input_tokens_details?.cache_write_tokens ??
+                    0;
                const trackedUsage: Record<string, number> = {
-                    ...OpenAiUtil.splitCachedPrompt(usage),
+                    prompt_tokens:
+                        ((usage as any).input_tokens ?? 0) -
+                        cachedTokens -
+                        cacheWriteTokens,
+                    completion_tokens: (usage as any).output_tokens ?? 0,
+                    cached_tokens: cachedTokens,
+                    ...(cacheWriteTokens
+                        ? { cache_write_tokens: cacheWriteTokens }
+                        : {}),
                    ...(webSearchCalls
                        ? { web_search_calls: webSearchCalls }
                        : {}),
@@ -359,11 +356,6 @@ export class OpenAiResponsesChatProvider implements IChatProvider {
                        : {},
                );
                setUsageCosts?.(metered.costs);
-                setUsageDetails?.(
-                    OpenAiUtil.usageDetailsFromTrackedUsage(metered.usage, {
-                        writeTtl: '30m',
-                    })!,
-                );
                return metered.usage;
            },
            stream,
@@ -23,8 +23,6 @@ import type { IChatModel } from '../../types.js';

 // Prompts over 272K input tokens are billed at 2x input (cached reads and
 // cache writes included) and 1.5x output for the full request.
-// GPT-5.6 and later bill cache writes by the lifetime requested: 1.25x input
-// for the default 30m entries, 2.5x for 12h entries.
 const GPT_LONG_CONTEXT_PRICING = {
    threshold: 272_000,
    input_multiplier: 2,
@@ -51,7 +49,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 100,
            cached_tokens: 5,
            cache_write_tokens: 100 * 1.25,
-            cache_write_12h_tokens: 100 * 2.5,
            completion_tokens: 500,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -77,7 +74,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 200,
            cached_tokens: 10,
            cache_write_tokens: 200 * 1.25,
-            cache_write_12h_tokens: 200 * 2.5,
            completion_tokens: 1000,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -103,7 +99,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 200,
            cached_tokens: 20,
            cache_write_tokens: 200 * 1.25,
-            cache_write_12h_tokens: 200 * 2.5,
            completion_tokens: 1000,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -129,7 +124,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 10,
            cached_tokens: 1,
            cache_write_tokens: 10 * 1.25,
-            cache_write_12h_tokens: 10 * 2.5,
            completion_tokens: 50,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -155,7 +149,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 1000,
            cached_tokens: 100,
            cache_write_tokens: 1000 * 1.25,
-            cache_write_12h_tokens: 1000 * 2.5,
            completion_tokens: 5000,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -181,7 +174,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 400,
            cached_tokens: 40,
            cache_write_tokens: 400 * 1.25,
-            cache_write_12h_tokens: 400 * 2.5,
            completion_tokens: 2000,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -206,7 +198,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 200,
            cached_tokens: 20,
            cache_write_tokens: 200 * 1.25,
-            cache_write_12h_tokens: 200 * 2.5,
            completion_tokens: 1200,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -231,7 +222,6 @@ export const OPEN_AI_MODELS: IChatModel[] = [
            prompt_tokens: 20,
            cached_tokens: 2,
            cache_write_tokens: 20 * 1.25,
-            cache_write_12h_tokens: 20 * 2.5,
            completion_tokens: 120,
        },
        long_context_pricing: GPT_LONG_CONTEXT_PRICING,
@@ -145,19 +145,13 @@ export type StopReason =
    | 'model_context_window_exceeded'
    | (string & {});

-/**
- * Provider-neutral usage breakdown. `inputTokens` excludes cache reads/writes.
- * Cache writes are keyed by the lifetime the entry was written with: Claude and
- * Moonshot write 5m and 1h entries, OpenAI writes 30m and 12h entries.
- */
+/** Provider-neutral usage breakdown. `inputTokens` excludes cache reads/writes. */
 export interface UsageDetails {
    inputTokens: number;
    outputTokens: number; // includes reasoning
    cacheReadTokens?: number;
    cacheWrite5mTokens?: number;
-    cacheWrite30mTokens?: number;
    cacheWrite1hTokens?: number;
-    cacheWrite12hTokens?: number;
    reasoningTokens?: number;
    webSearchRequests?: number;
    webFetchRequests?: number;
@@ -174,30 +168,13 @@ export interface UsageDetails {
        outputTokens: number;
        cacheReadTokens?: number;
        cacheWrite5mTokens?: number;
-        cacheWrite30mTokens?: number;
        cacheWrite1hTokens?: number;
-        cacheWrite12hTokens?: number;
    }>;
 }

-/**
- * OpenAI `prompt_cache_options`, GPT-5.6 and later. `ttl` is the minimum
- * lifetime of every cache entry the request writes; `12h` entries cost twice
- * what `30m` entries do to write and only the Responses API writes them.
- */
-export interface PromptCacheOptions {
-    mode?: 'implicit' | 'explicit';
-    ttl?: '30m' | '12h';
-}
-
 export interface ICompleteArguments {
    messages: PuterMessage[];
    provider?: string;
-    /**
-     * `false` makes the first route's failure final instead of retrying the
-     * request on another provider that serves the same model.
-     */
-    fallback?: boolean;
    stream?: boolean;
    model: string;
    test_mode?: boolean;
@@ -252,9 +229,7 @@ export interface ICompleteArguments {
    metadata?: Record<string, string>;
    prompt?: unknown;
    prompt_cache_key?: string;
-    /** `in-memory` is accepted as a spelling of OpenAI's `in_memory`. */
-    prompt_cache_retention?: 'in-memory' | 'in_memory' | '24h' | undefined;
-    prompt_cache_options?: PromptCacheOptions;
+    prompt_cache_retention?: 'in-memory' | '24h' | undefined;
    store?: boolean;
    top_p?: number;
    truncation?: 'auto' | 'disabled' | undefined;
@@ -481,86 +481,43 @@ export const extractMeteredUsage = (usage) => {
 };

 /**
- * @typedef {{
- *     cached_tokens?: number | null;
- *     cache_write_tokens?: number | null;
- *     cache_write_tokens_details?: {
- *         ttl_30m_tokens?: number | null;
- *         ttl_12h_tokens?: number | null;
- *     } | null;
- * }} OpenAiCacheDetails
- */
-
-/**
- * OpenAI-shaped usage as it's metered. The prompt count reports cached reads
- * and cache writes inside it, so they come out of it and are priced once each
- * under their own keys: `cached_tokens` for reads, `cache_write_tokens` for
- * writes at the model's default lifetime and `cache_write_12h_tokens` for
- * writes at OpenAI's 12h lifetime. Without the per-lifetime breakdown every
- * write is a default-lifetime write: Chat Completions writes no 12h entries,
- * and Responses reports the breakdown whenever a request asked for them. Reads
- * the Chat Completions (`prompt_tokens`) and Responses (`input_tokens`)
- * spellings alike.
+ * Chat Completions usage as it's metered: `prompt_tokens` reports cached reads
+ * inside its count, so they come out of it and are priced only once, under
+ * `cached_tokens`.
 *
- * @param {{
- *           prompt_tokens?: number;
- *           completion_tokens?: number;
- *           prompt_tokens_details?: OpenAiCacheDetails | null;
- *           input_tokens?: number;
- *           output_tokens?: number;
- *           input_tokens_details?: OpenAiCacheDetails | null;
- *       }
- *     | undefined} usage
+ * @param {import('openai/resources/completions.mjs').CompletionUsage | undefined} usage
 */
 export const splitCachedPrompt = (usage) => {
-    const details = usage?.prompt_tokens_details ?? usage?.input_tokens_details;
+    const details = usage?.prompt_tokens_details;
    const cachedTokens = details?.cached_tokens ?? 0;
-    // Moonshot and GPT-5.6+ count the prompt tokens they wrote to the prefix
-    // cache here; they're billed at the model's write rate, not the prompt rate.
+    // Moonshot counts the prompt tokens it wrote to its prefix cache here;
+    // they're billed at the model's write rate, not the plain prompt rate.
    const writeTokens =
        typeof details?.cache_write_tokens === 'number'
            ? details.cache_write_tokens
            : undefined;
-    const reported12h = details?.cache_write_tokens_details?.ttl_12h_tokens;
-    const write12hTokens =
-        typeof reported12h === 'number'
-            ? Math.min(reported12h, writeTokens ?? 0)
-            : undefined;
    return {
        prompt_tokens:
-            (usage?.prompt_tokens ?? usage?.input_tokens ?? 0) -
-            cachedTokens -
-            (writeTokens ?? 0),
-        completion_tokens:
-            usage?.completion_tokens ?? usage?.output_tokens ?? 0,
+            (usage?.prompt_tokens ?? 0) - cachedTokens - (writeTokens ?? 0),
+        completion_tokens: usage?.completion_tokens ?? 0,
        cached_tokens: cachedTokens,
        ...(writeTokens !== undefined
-            ? { cache_write_tokens: writeTokens - (write12hTokens ?? 0) }
-            : {}),
-        ...(write12hTokens !== undefined
-            ? { cache_write_12h_tokens: write12hTokens }
+            ? { cache_write_tokens: writeTokens }
            : {}),
    };
 };

 /**
- * The `{prompt_tokens, completion_tokens, cached_tokens, cache_write_tokens,
- * cache_write_12h_tokens}` shape every OpenAI-family `usage_calculator` already
- * returns for billing, mapped to the provider-neutral `UsageDetails` the
- * end-of-stream/non-stream result carries. `inputTokens`/`outputTokens` are the
- * same numbers already billed — this never introduces a new figure, only
- * exposes the breakdown.
+ * The `{prompt_tokens, completion_tokens, cached_tokens, cache_write_tokens}`
+ * shape every OpenAI-family `usage_calculator` already returns for billing,
+ * mapped to the provider-neutral `UsageDetails` the end-of-stream/non-stream
+ * result carries. `inputTokens`/`outputTokens` are the same numbers already
+ * billed — this never introduces a new figure, only exposes the breakdown.
 *
 * @param {Record<string, number> | undefined | null} trackedUsage
- * @param {{ writeTtl?: '5m' | '30m' }} [opts] The lifetime `cache_write_tokens`
- *   were written with: 5m unless the provider says otherwise (OpenAI's default
- *   entries live 30m).
 * @returns {import('../types.js').UsageDetails | undefined}
 */
-export const usageDetailsFromTrackedUsage = (
-    trackedUsage,
-    { writeTtl = '5m' } = {},
-) => {
+export const usageDetailsFromTrackedUsage = (trackedUsage) => {
    if (!trackedUsage || typeof trackedUsage !== 'object') return undefined;
    // OpenRouter, Infron and Ollama track `{prompt, completion,
    // input_cache_read}` instead; any other shape is left to the driver.
@@ -569,19 +526,12 @@ export const usageDetailsFromTrackedUsage = (
    if (input === undefined && output === undefined) return undefined;
    const cacheRead =
        trackedUsage.cached_tokens ?? trackedUsage.input_cache_read;
-    const cacheWrite = trackedUsage.cache_write_tokens;
    return {
        inputTokens: input ?? 0,
        outputTokens: output ?? 0,
        ...(cacheRead ? { cacheReadTokens: cacheRead } : {}),
-        ...(cacheWrite && writeTtl === '30m'
-            ? { cacheWrite30mTokens: cacheWrite }
-            : {}),
-        ...(cacheWrite && writeTtl !== '30m'
-            ? { cacheWrite5mTokens: cacheWrite }
-            : {}),
-        ...(trackedUsage.cache_write_12h_tokens
-            ? { cacheWrite12hTokens: trackedUsage.cache_write_12h_tokens }
+        ...(trackedUsage.cache_write_tokens
+            ? { cacheWrite5mTokens: trackedUsage.cache_write_tokens }
            : {}),
    };
 };
@@ -914,16 +864,12 @@ export const create_chat_stream_handler_responses_api =
        // Missing usage is left undefined rather than fed to the calculator —
        // see the sibling handler above, including why usage is reported
        // before the block flushes.
-        let usageDetails;
        const usage = last_usage
            ? usage_calculator({
                  usage: last_usage,
                  webSearchCalls,
                  tool_usage: toolUsage,
                  setUsageCosts: (c) => chatStream.setUsageCosts(c),
-                  setUsageDetails: (d) => {
-                      usageDetails = d;
-                  },
              })
            : undefined;
        chatStream.reportUsage(usage);
@@ -931,7 +877,7 @@ export const create_chat_stream_handler_responses_api =
            reason:
                incompleteReason ?? (sawFunctionCall ? 'tool_use' : 'end_turn'),
        });
-        usageDetails ??= usageDetailsFromTrackedUsage(usage);
+        const usageDetails = usageDetailsFromTrackedUsage(usage);
        if (usageDetails) chatStream.setUsageDetails(usageDetails);

        textblock.end();
@@ -1069,7 +1015,6 @@ export const handle_completion_output = async (
 *     webSearchCalls?: number;
 *     tool_usage?: Record<string, unknown>;
 *     setUsageCosts?: (costs: Record<string, number>) => void;
- *     setUsageDetails?: (details: import('../types').UsageDetails) => void;
 * }) => unknown} params.usage_calculator
 * @param {() => Promise<void>} [params.finally_fn]
 * @returns {ReturnType<import('../types').IChatProvider['complete']>}
@@ -1211,15 +1156,12 @@ export const handle_completion_output_responses_api = async ({
              setUsageCosts: (c) => {
                  ret.usageCosts = c;
              },
-              setUsageDetails: (d) => {
-                  ret.usageDetails = d;
-              },
          })
        : {
              input_tokens: completion.usage.input_tokens,
              output_tokens: completion.usage.output_tokens,
          };
-    if (usage_calculator && ret.usageDetails === undefined) {
+    if (usage_calculator) {
        const usageDetails = usageDetailsFromTrackedUsage(ret.usage);
        if (usageDetails) ret.usageDetails = usageDetails;
    }
@@ -247,40 +247,6 @@ describe('usageDetailsFromTrackedUsage', () => {
        });
    });

-    it('labels cache writes by the lifetime the provider says it wrote them with', () => {
-        expect(
-            usageDetailsFromTrackedUsage(
-                {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    cached_tokens: 3,
-                    cache_write_tokens: 11,
-                    cache_write_12h_tokens: 6012,
-                },
-                { writeTtl: '30m' },
-            ),
-        ).toEqual({
-            inputTokens: 10,
-            outputTokens: 5,
-            cacheReadTokens: 3,
-            cacheWrite30mTokens: 11,
-            cacheWrite12hTokens: 6012,
-        });
-        // Zero counts, as OpenAI reports on a cache hit, add no field.
-        expect(
-            usageDetailsFromTrackedUsage(
-                {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    cached_tokens: 3,
-                    cache_write_tokens: 0,
-                    cache_write_12h_tokens: 0,
-                },
-                { writeTtl: '30m' },
-            ),
-        ).toEqual({ inputTokens: 10, outputTokens: 5, cacheReadTokens: 3 });
-    });
-
    it('returns undefined for a missing/non-object usage', () => {
        expect(usageDetailsFromTrackedUsage(undefined)).toBeUndefined();
        expect(usageDetailsFromTrackedUsage(null)).toBeUndefined();
@@ -996,66 +962,6 @@ describe('splitCachedPrompt', () => {
            cached_tokens: 3,
        });
    });
-
-    it('reads the Responses usage spelling', () => {
-        expect(
-            splitCachedPrompt({
-                input_tokens: 6026,
-                output_tokens: 5,
-                input_tokens_details: { cached_tokens: 0, cache_write_tokens: 6023 },
-            }),
-        ).toEqual({
-            prompt_tokens: 3,
-            completion_tokens: 5,
-            cached_tokens: 0,
-            cache_write_tokens: 6023,
-        });
-    });
-
-    it('splits 12h writes out of the write count when the breakdown is reported', () => {
-        // One request can write both lifetimes: an explicit 12h breakpoint
-        // plus the implicit 30m one OpenAI adds at the end of the prompt.
-        expect(
-            splitCachedPrompt({
-                input_tokens: 6026,
-                output_tokens: 5,
-                input_tokens_details: {
-                    cached_tokens: 0,
-                    cache_write_tokens: 6023,
-                    cache_write_tokens_details: {
-                        ttl_12h_tokens: 6012,
-                        ttl_30m_tokens: 11,
-                    },
-                },
-            }),
-        ).toEqual({
-            prompt_tokens: 3,
-            completion_tokens: 5,
-            cached_tokens: 0,
-            cache_write_tokens: 11,
-            cache_write_12h_tokens: 6012,
-        });
-    });
-
-    it('never reports more 12h writes than writes in total', () => {
-        expect(
-            splitCachedPrompt({
-                input_tokens: 100,
-                output_tokens: 1,
-                input_tokens_details: {
-                    cached_tokens: 0,
-                    cache_write_tokens: 40,
-                    cache_write_tokens_details: { ttl_12h_tokens: 50 },
-                },
-            }),
-        ).toEqual({
-            prompt_tokens: 60,
-            completion_tokens: 1,
-            cached_tokens: 0,
-            cache_write_tokens: 0,
-            cache_write_12h_tokens: 40,
-        });
-    });
 });

 // ── recorded usage costs ────────────────────────────────────────────
@@ -22,14 +22,11 @@ import { describe, expect, it } from 'vitest';
 import type { ICompleteArguments } from '../types.js';
 import {
    clampReasoningEffort,
-    messagesHaveCacheBreakpointTtl,
    openAICompatParams,
    outputFormatFromResponseFormat,
    outputFormatFromResponsesText,
    outputFormatToResponseFormat,
    outputFormatToResponsesText,
-    promptCacheOptionsToWire,
-    promptCacheRetentionToWire,
    rejectStatefulResponsesFields,
    toolChoiceFromWire,
    toolChoiceToWire,
@@ -337,109 +334,3 @@ describe('rejectStatefulResponsesFields', () => {
        ).toThrow(/previous_response_id/);
    });
 });
-
-describe('promptCacheRetentionToWire', () => {
-    it('spells the in-memory retention the way the upstreams expect', () => {
-        expect(promptCacheRetentionToWire('in-memory')).toBe('in_memory');
-        expect(promptCacheRetentionToWire('in_memory')).toBe('in_memory');
-        expect(promptCacheRetentionToWire('24h')).toBe('24h');
-        expect(promptCacheRetentionToWire(undefined)).toBeUndefined();
-    });
-});
-
-describe('promptCacheOptionsToWire', () => {
-    it('forwards mode and ttl and nothing else', () => {
-        expect(
-            promptCacheOptionsToWire({
-                mode: 'explicit',
-                ttl: '12h',
-                prewarm: true,
-                comparison_response_id: 'resp_1',
-            }),
-        ).toEqual({ mode: 'explicit', ttl: '12h' });
-        expect(promptCacheOptionsToWire({ ttl: '30m' })).toEqual({
-            ttl: '30m',
-        });
-    });
-
-    it('sends nothing for an absent or empty object', () => {
-        expect(promptCacheOptionsToWire(undefined)).toBeUndefined();
-        expect(promptCacheOptionsToWire(null)).toBeUndefined();
-        expect(promptCacheOptionsToWire({})).toBeUndefined();
-        expect(promptCacheOptionsToWire({ prewarm: true })).toBeUndefined();
-    });
-
-    it('rejects a lifetime or mode OpenAI does not offer', () => {
-        expect(() => promptCacheOptionsToWire({ ttl: '2h' })).toThrow(
-            expect.objectContaining({ statusCode: 400 }),
-        );
-        expect(() => promptCacheOptionsToWire({ ttl: '24h' })).toThrow(
-            /30m.*12h/,
-        );
-        expect(() => promptCacheOptionsToWire({ mode: 'auto' })).toThrow(
-            /implicit.*explicit/,
-        );
-        expect(() => promptCacheOptionsToWire('12h')).toThrow(
-            /must be an object/,
-        );
-    });
-});
-
-describe('messagesHaveCacheBreakpointTtl', () => {
-    it('finds a breakpoint lifetime on any content part', () => {
-        expect(
-            messagesHaveCacheBreakpointTtl([
-                { role: 'user', content: 'plain' },
-                {
-                    role: 'system',
-                    content: [
-                        { type: 'text', text: 'a' },
-                        {
-                            type: 'text',
-                            text: 'b',
-                            prompt_cache_breakpoint: {
-                                mode: 'explicit',
-                                ttl: '30m',
-                            },
-                        },
-                    ],
-                },
-            ]),
-        ).toBe(true);
-        expect(
-            messagesHaveCacheBreakpointTtl([
-                {
-                    role: 'user',
-                    content: {
-                        type: 'text',
-                        text: 'a',
-                        prompt_cache_breakpoint: { ttl: '12h' },
-                    },
-                },
-            ]),
-        ).toBe(true);
-    });
-
-    it('ignores breakpoints without a lifetime and odd message shapes', () => {
-        expect(
-            messagesHaveCacheBreakpointTtl([
-                {
-                    role: 'system',
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'a',
-                            prompt_cache_breakpoint: { mode: 'explicit' },
-                        },
-                        'bare string part',
-                        null,
-                    ],
-                },
-                { role: 'user', content: null },
-                null,
-            ]),
-        ).toBe(false);
-        expect(messagesHaveCacheBreakpointTtl(undefined)).toBe(false);
-        expect(messagesHaveCacheBreakpointTtl('nope')).toBe(false);
-    });
-});
@@ -29,7 +29,6 @@ import { HttpError } from '../../../core/http/HttpError.js';
 import type {
    ICompleteArguments,
    OutputFormat,
-    PromptCacheOptions,
    ReasoningEffort,
    ToolChoice,
 } from '../types.js';
@@ -306,80 +305,6 @@ export const openAICompatParams = (
    return out;
 };

-// -- prompt caching ----------------------------------------------------------
-
-/**
- * The wire spelling of `prompt_cache_retention`. Puter also accepts the
- * hyphenated `in-memory`, which every OpenAI-shaped upstream rejects.
- */
-export const promptCacheRetentionToWire = (
-    retention: ICompleteArguments['prompt_cache_retention'],
-): 'in_memory' | '24h' | undefined =>
-    retention === 'in-memory' ? 'in_memory' : retention;
-
-const PROMPT_CACHE_MODES = new Set(['implicit', 'explicit']);
-const PROMPT_CACHE_TTLS = new Set(['30m', '12h']);
-
-/**
- * `prompt_cache_options` as forwarded upstream: `mode` and `ttl` only, each
- * checked against the values OpenAI accepts, so a bad value fails here with a
- * clear message instead of as an upstream 400 the fallback loop may hide.
- * `comparison_response_id` names a stored response, which Puter never keeps,
- * and `prewarm` is dropped with it.
- */
-export const promptCacheOptionsToWire = (
-    options: unknown,
-): PromptCacheOptions | undefined => {
-    if (options === undefined || options === null) return undefined;
-    if (typeof options !== 'object' || Array.isArray(options)) {
-        throw new HttpError(400, '`prompt_cache_options` must be an object', {
-            legacyCode: 'bad_request',
-        });
-    }
-    const { mode, ttl } = options as Record<string, unknown>;
-    if (mode !== undefined && !PROMPT_CACHE_MODES.has(mode as string)) {
-        throw new HttpError(
-            400,
-            '`prompt_cache_options.mode` must be `implicit` or `explicit`',
-            { legacyCode: 'bad_request' },
-        );
-    }
-    if (ttl !== undefined && !PROMPT_CACHE_TTLS.has(ttl as string)) {
-        throw new HttpError(
-            400,
-            '`prompt_cache_options.ttl` must be `30m` or `12h`',
-            { legacyCode: 'bad_request' },
-        );
-    }
-    const wire: PromptCacheOptions = {
-        ...(mode !== undefined
-            ? { mode: mode as PromptCacheOptions['mode'] }
-            : {}),
-        ...(ttl !== undefined ? { ttl: ttl as PromptCacheOptions['ttl'] } : {}),
-    };
-    return Object.keys(wire).length ? wire : undefined;
-};
-
-/**
- * Whether any content part carries a `prompt_cache_breakpoint` with its own
- * `ttl`. Chat Completions rejects the field whatever its value; only the
- * Responses API honours a per-breakpoint lifetime.
- */
-export const messagesHaveCacheBreakpointTtl = (messages: unknown): boolean =>
-    Array.isArray(messages) &&
-    messages.some((message) => {
-        const content = (message as { content?: unknown } | null)?.content;
-        const parts = Array.isArray(content) ? content : [content];
-        return parts.some(
-            (part) =>
-                (
-                    part as {
-                        prompt_cache_breakpoint?: { ttl?: unknown } | null;
-                    } | null
-                )?.prompt_cache_breakpoint?.ttl !== undefined,
-        );
-    });
-
 // -- Responses server-side state ---------------------------------------------

 const STATEFUL_RESPONSES_FIELDS = [
@@ -39,49 +39,9 @@ describe('estimateTextTokens', () => {
        const long = estimateTextTokens('hello world '.repeat(100));
        expect(long).toBeGreaterThan(short);
    });
-
-    it('counts words the way splitting on \\s+ does', () => {
-        const splitEstimate = (text: string) =>
-            Math.floor(
-                (text.length / 4 + text.split(/\s+/).length * (4 / 3)) / 2,
-            );
-        for (const text of [
-            'a',
-            ' a',
-            'a ',
-            '  a  b\t\nc  ',
-            'x y z w     　v',
-            'é ü 日本語 テキスト',
-            '\r\n\v\f',
-        ]) {
-            expect(estimateTextTokens(text), JSON.stringify(text)).toBe(
-                splitEstimate(text),
-            );
-        }
-    });
-
-    it('gives text past the scan budget the word density scanned so far', () => {
-        const text = 'ab cd '.repeat(1000);
-        const budget = { chars: 12, scannedChars: 0, scannedRuns: 0 };
-        // Uniform text extrapolates to the full count.
-        expect(estimateTextTokens(text, budget)).toBe(estimateTextTokens(text));
-        expect(budget.chars).toBe(0);
-        // A later part with no budget left takes the same density.
-        expect(estimateTextTokens(text, budget)).toBe(estimateTextTokens(text));
-    });
 });

 describe('estimatePromptTokens', () => {
-    it('scans a bounded amount of text per prompt', () => {
-        // Many parts, each under the budget alone, past it together; the
-        // unscanned ones are extrapolated, which is exact for uniform text.
-        const part = 'lorem ipsum dolor '.repeat(30_000);
-        const parts = Array.from({ length: 8 }, () => ({ text: part }));
-        expect(estimatePromptTokens([{ role: 'user', content: parts }])).toBe(
-            8 * estimateTextTokens(part),
-        );
-    });
-
    it('counts plain string content', () => {
        const tokens = estimatePromptTokens([
            { role: 'user', content: 'a fairly ordinary sentence to price' },
@@ -29,11 +29,7 @@
 * passes every gate.
 */

-import {
-    createWordScanBudget,
-    estimateTextTokens,
-    type WordScanBudget,
-} from '../../util/tokenEstimate.js';
+import { estimateTextTokens } from '../../util/tokenEstimate.js';

 // Re-exported so existing consumers keep one import site for all estimators.
 export { estimateTextTokens } from '../../util/tokenEstimate.js';
@@ -95,25 +91,23 @@ const attachmentTokens = (value: unknown): number => {
 * recognises is charged the unmeasured estimate — the alternative is a content
 * type nobody has taught the gate about arriving for free.
 */
-const partTokens = (part: unknown, budget: WordScanBudget): number => {
-    if (typeof part === 'string') return estimateTextTokens(part, budget);
+const partTokens = (part: unknown): number => {
+    if (typeof part === 'string') return estimateTextTokens(part);
    if (!part || typeof part !== 'object') return 0;

    const p = part as ContentPart;

-    if (typeof p.text === 'string') return estimateTextTokens(p.text, budget);
+    if (typeof p.text === 'string') return estimateTextTokens(p.text);

    // Model-output shapes replayed as history: Anthropic thinking blocks,
    // our own streamed `reasoning` chunks, OpenAI refusals. All text — they
    // must not fall through to the attachment default below, which would
    // price a few sentences of reasoning like a full-frame image.
-    if (typeof p.thinking === 'string')
-        return estimateTextTokens(p.thinking, budget);
+    if (typeof p.thinking === 'string') return estimateTextTokens(p.thinking);
    if (typeof p.reasoning === 'string') {
-        return estimateTextTokens(p.reasoning, budget);
+        return estimateTextTokens(p.reasoning);
    }
-    if (typeof p.refusal === 'string')
-        return estimateTextTokens(p.refusal, budget);
+    if (typeof p.refusal === 'string') return estimateTextTokens(p.refusal);

    // OpenAI-style `{ image_url: { url } }` (or the flattened string form).
    if (p.image_url) {
@@ -142,7 +136,6 @@ const partTokens = (part: unknown, budget: WordScanBudget): number => {
    if (p.type === 'tool_use' && p.input !== undefined) {
        return estimateTextTokens(
            typeof p.input === 'string' ? p.input : JSON.stringify(p.input),
-            budget,
        );
    }
    if (p.type === 'tool_result') {
@@ -150,11 +143,10 @@ const partTokens = (part: unknown, budget: WordScanBudget): number => {
            typeof p.content === 'string'
                ? p.content
                : JSON.stringify(p.content ?? ''),
-            budget,
        );
    }
    if (p.type === 'compaction') {
-        return estimateTextTokens(String(p.encrypted_content ?? ''), budget);
+        return estimateTextTokens(String(p.encrypted_content ?? ''));
    }

    return UNMEASURED_ATTACHMENT_TOKENS;
@@ -172,22 +164,21 @@ const partTokens = (part: unknown, budget: WordScanBudget): number => {
 export const estimatePromptTokens = (messages: unknown): number => {
    if (!Array.isArray(messages)) return 0;

-    const budget = createWordScanBudget();
    let tokens = 0;
    for (const message of messages) {
        if (typeof message === 'string') {
-            tokens += estimateTextTokens(message, budget);
+            tokens += estimateTextTokens(message);
            continue;
        }
        if (!message || typeof message !== 'object') continue;

        const content = (message as ContentPart).content;
        if (typeof content === 'string') {
-            tokens += estimateTextTokens(content, budget);
+            tokens += estimateTextTokens(content);
        } else if (Array.isArray(content)) {
-            for (const part of content) tokens += partTokens(part, budget);
+            for (const part of content) tokens += partTokens(part);
        } else if (content) {
-            tokens += partTokens(content, budget);
+            tokens += partTokens(content);
        }
    }
    return tokens;
@@ -463,26 +463,10 @@ describe('ImageGenerationDriver.generate provider routing', () => {
            driver.generate({ prompt: 'a landscape' }),
        );
        expect(openaiImagesGenerateMock).toHaveBeenCalledWith(
-            expect.objectContaining({ model: 'gpt-image-2.6-flare' }),
+            expect.objectContaining({ model: 'gpt-image-2' }),
        );
    });

-    it.each(['gpt-image-2.6-flare', 'gpt-image-2.6-sunburst'])(
-        'routes %s and its OpenAI alias', async (model) => {
-            for (const id of [model, `openai/${model}`]) {
-                openaiImagesGenerateMock.mockResolvedValueOnce({
-                    data: [{ url: 'https://oai/image.png' }],
-                });
-                await withDriverName('ai-image', () => driver.generate({
-                    model: id, prompt: 'a landscape',
-                }));
-                expect(openaiImagesGenerateMock).toHaveBeenLastCalledWith(
-                    expect.objectContaining({ model }),
-                );
-            }
-        },
-    );
-
    it('rejects an excluded model regardless of caller casing', async () => {
        await expect(withActor(() =>
            driver.generate({
@@ -758,10 +742,7 @@ describe('ImageGenerationDriver.generate provider routing', () => {
            }),
        );

-        const reserveSpy = vi.spyOn(
-            server.services.metering,
-            'reserveCreditsIfAffordable',
-        );
+        const reserveSpy = vi.spyOn(server.services.metering, 'reserveCredits');
        const usageSpy = vi.spyOn(
            server.services.metering,
            'batchIncrementUsages',
@@ -855,7 +836,7 @@ describe('ImageGenerationDriver.generate provider routing', () => {
            });
            const reserveSpy = vi.spyOn(
                server.services.metering,
-                'reserveCreditsIfAffordable',
+                'reserveCredits',
            );

            // Cloudflare answers the scheduled refresh with new rates at once;
@@ -1165,8 +1146,8 @@ describe('ImageGenerationDriver.generate Puter file inputs', () => {
        );

    beforeEach(() => {
-        vi.spyOn(server.services.metering, 'reserveCreditsIfAffordable').mockImplementation((who, amount, opts) =>
-            server.services.metering.reserveCredits(who, amount, opts),
+        vi.spyOn(server.services.metering, 'hasEnoughCredits').mockResolvedValue(
+            true,
        );
    });

@@ -1668,10 +1649,7 @@ it.each([undefined, null, '', '  ', 42, {}])(

 describe('ImageGenerationDriver cost factor', () => {
    it('holds and meters at the AI cost factor', async () => {
-        const reserveSpy = vi.spyOn(
-            server.services.metering,
-            'reserveCreditsIfAffordable',
-        );
+        const reserveSpy = vi.spyOn(server.services.metering, 'reserveCredits');
        const usageSpy = vi.spyOn(
            server.services.metering,
            'batchIncrementUsages',
@@ -72,7 +72,7 @@ vi.mock('openai', () => {
 // -- Test harness ----------------------------------------------------

 let server: PuterServer;
-let admitSpy: MockInstance<MeteringService['reserveCreditsIfAffordable']>;
+let hasCreditsSpy: MockInstance<MeteringService['hasEnoughCredits']>;
 let batchIncrementUsagesSpy: MockInstance<
    MeteringService['batchIncrementUsages']
 >;
@@ -107,7 +107,7 @@ const makeProvider = (
 beforeEach(() => {
    generateMock.mockReset();
    openAICtor.mockReset();
-    admitSpy = vi.spyOn(server.services.metering, 'reserveCreditsIfAffordable');
+    hasCreditsSpy = vi.spyOn(server.services.metering, 'hasEnoughCredits');
    batchIncrementUsagesSpy = vi.spyOn(
        server.services.metering,
        'batchIncrementUsages',
@@ -177,7 +177,7 @@ describe('BytePlusImageProvider.generate gates', () => {
        expect(result).toBe(
            'https://puter-sample-data.puter.site/image_example.png',
        );
-        expect(admitSpy).not.toHaveBeenCalled();
+        expect(hasCreditsSpy).not.toHaveBeenCalled();
        expect(generateMock).not.toHaveBeenCalled();
    });

@@ -196,7 +196,7 @@ describe('BytePlusImageProvider.generate gates', () => {
    });

    it('throws 402 BEFORE hitting ModelArk when the actor lacks credits', async () => {
-        admitSpy.mockResolvedValueOnce(null);
+        hasCreditsSpy.mockResolvedValueOnce(false);
        await expect(
            withTestActor(() => makeProvider().generate({ prompt: 'hi' })),
        ).rejects.toMatchObject({ statusCode: 402 });
@@ -713,7 +713,7 @@ it.each([
            }),
        ),
    ).rejects.toMatchObject({ statusCode: 400, legacyCode: 'bad_request' });
-    expect(admitSpy).not.toHaveBeenCalled();
+    expect(hasCreditsSpy).not.toHaveBeenCalled();
    expect(generateMock).not.toHaveBeenCalled();
 });

@@ -73,7 +73,7 @@ let server: PuterServer;
 let globalFetchSpy: MockInstance<typeof fetch>;
 let fetchSpy: Mock<typeof fetch>;
 let modelSearchFetch: Mock<typeof fetch>;
-let admitSpy: MockInstance<MeteringService['reserveCreditsIfAffordable']>;
+let hasCreditsSpy: MockInstance<MeteringService['hasEnoughCredits']>;
 let batchIncrementUsagesSpy: MockInstance<
    MeteringService['batchIncrementUsages']
 >;
@@ -123,7 +123,7 @@ beforeEach(() => {
                ? modelSearchFetch(input, init)
                : fetchSpy(input, init),
        );
-    admitSpy = vi.spyOn(server.services.metering, 'reserveCreditsIfAffordable');
+    hasCreditsSpy = vi.spyOn(server.services.metering, 'hasEnoughCredits');
    batchIncrementUsagesSpy = vi.spyOn(
        server.services.metering,
        'batchIncrementUsages',
@@ -188,7 +188,7 @@ describe('CloudflareImageProvider.generate test_mode', () => {
        expect(result).toBe(
            'https://puter-sample-data.puter.site/image_example.png',
        );
-        expect(admitSpy).not.toHaveBeenCalled();
+        expect(hasCreditsSpy).not.toHaveBeenCalled();
        expect(fetchSpy).not.toHaveBeenCalled();
    });
 });
@@ -210,7 +210,7 @@ describe('CloudflareImageProvider.generate argument validation', () => {
 describe('CloudflareImageProvider.generate credit gate', () => {
    it('throws 402 BEFORE hitting Cloudflare when actor lacks credits', async () => {
        const provider = makeProvider();
-        admitSpy.mockResolvedValueOnce(null);
+        hasCreditsSpy.mockResolvedValueOnce(false);

        await expect(
            withTestActor(() => provider.generate({ prompt: 'hi' })),
@@ -240,7 +240,7 @@ describe('CloudflareImageProvider.generate credit gate', () => {
            actor,
        );

-        const [, estimate] = admitSpy.mock.calls[0]!;
+        const [, estimate] = hasCreditsSpy.mock.calls[0]!;
        expect(estimate).toBeGreaterThan(0);
        expect(heldDuringCall).toBe(Math.ceil(estimate));
        // The hold stays until the usage write lands.
@@ -708,7 +708,7 @@ describe('Cloudflare legacy image option', () => {
                legacyCode: 'bad_request',
            });
            expect(fetchSpy).not.toHaveBeenCalled();
-            expect(admitSpy).not.toHaveBeenCalled();
+            expect(hasCreditsSpy).not.toHaveBeenCalled();
        },
    );

@@ -726,7 +726,7 @@ describe('Cloudflare legacy image option', () => {
            message: 'Invalid input image (empty or not base64)',
        });
        expect(fetchSpy).not.toHaveBeenCalled();
-        expect(admitSpy).not.toHaveBeenCalled();
+        expect(hasCreditsSpy).not.toHaveBeenCalled();
    });
 });

@@ -823,12 +823,12 @@ describe('Cloudflare priced legacy models', () => {
            imageSize: { kind: 'pixels', w: 512, h: 512 },
        }));
        expect(JSON.parse(fetchSpy.mock.calls[0]![1]!.body as string)).toMatchObject({ image: [1, 2, 3], mask: [4, 5, 6], num_steps: 20, width: 512, height: 512 });
-        expect(admitSpy).toHaveBeenCalledWith(expect.anything(), 0, undefined);
+        expect(hasCreditsSpy).toHaveBeenCalledWith(expect.anything(), 0);
    });

    it('rejects missing inpainting inputs before credit checks', async () => {
        await expect(withTestActor(() => makeProvider().generate({ model: '@cf/runwayml/stable-diffusion-v1-5-inpainting', prompt: 'A cup' }))).rejects.toMatchObject({ statusCode: 400 });
-        expect(admitSpy).not.toHaveBeenCalled();
+        expect(hasCreditsSpy).not.toHaveBeenCalled();
        expect(fetchSpy).not.toHaveBeenCalled();
    });

@@ -844,7 +844,7 @@ describe('Cloudflare priced legacy models', () => {
    it('charges Lucid at the price returned by the model API', async () => {
        fetchSpy.mockResolvedValueOnce(new Response(new Uint8Array([1, 2, 3]), { headers: { 'content-type': 'image/png' } }));
        await withTestActor(() => makeProvider().generate({ model: '@cf/leonardo/lucid-origin', prompt: 'A cup', imageSize: { kind: 'pixels', w: 512, h: 512 }, steps: 1 }));
-        expect(admitSpy).toHaveBeenCalledWith(expect.anything(), 713200, undefined);
+        expect(hasCreditsSpy).toHaveBeenCalledWith(expect.anything(), 713200);
    });
 });

@@ -897,10 +897,9 @@ describe('Cloudflare model-search pricing', () => {
        await runPhoenix(provider);

        expect(listed?.costs).toEqual({ tile_512: 1_000_000, step: 20_200 });
-        expect(admitSpy).toHaveBeenCalledWith(
+        expect(hasCreditsSpy).toHaveBeenCalledWith(
            expect.anything(),
            4 * 1_000_000 + 10 * 20_200,
-            undefined,
        );
        expect(batchIncrementUsagesSpy.mock.calls[0]![1]).toEqual([
            expect.objectContaining({
@@ -931,10 +930,9 @@ describe('Cloudflare model-search pricing', () => {
        await runPhoenix(makeProvider());

        expect(modelSearchFetch).not.toHaveBeenCalled();
-        expect(admitSpy).toHaveBeenCalledWith(
+        expect(hasCreditsSpy).toHaveBeenCalledWith(
            expect.anything(),
            4 * 583_000 + 10 * 11_000,
-            undefined,
        );
    });

@@ -957,7 +955,7 @@ describe('Cloudflare model-search pricing', () => {
        await refresh;
        await runPhoenix(provider);

-        expect(admitSpy.mock.calls.map(([, cost]) => cost)).toEqual([
+        expect(hasCreditsSpy.mock.calls.map(([, cost]) => cost)).toEqual([
            2_442_000, 4_202_000,
        ]);
    });
@@ -979,10 +977,9 @@ describe('Cloudflare model-search pricing', () => {
        await runPhoenix(provider);

        expect(modelSearchFetch).toHaveBeenCalledTimes(2);
-        expect(admitSpy).toHaveBeenCalledWith(
+        expect(hasCreditsSpy).toHaveBeenCalledWith(
            expect.anything(),
            4_202_000,
-            undefined,
        );
    });

@@ -1018,7 +1015,7 @@ describe('Cloudflare model-search pricing', () => {
                    steps: 10,
                } as never),
            );
-            return admitSpy.mock.lastCall![1];
+            return hasCreditsSpy.mock.lastCall![1];
        };
        const settle = () => new Promise((resolve) => setImmediate(resolve));
        const OLD = { tile_512: 583_000, step: 11_000 };
@@ -1072,10 +1069,9 @@ describe('Cloudflare model-search pricing', () => {
            }),
        );
        expect(modelSearchFetch).toHaveBeenCalledOnce();
-        expect(admitSpy).toHaveBeenCalledWith(
+        expect(hasCreditsSpy).toHaveBeenCalledWith(
            expect.anything(),
            4 * 5280 + 4 * 10560,
-            undefined,
        );
    });

@@ -82,7 +82,7 @@ vi.mock('../../inputImage.js', async (orig) => ({
 // ── Test harness ────────────────────────────────────────────────────

 let server: PuterServer;
-let admitSpy: MockInstance<MeteringService['reserveCreditsIfAffordable']>;
+let hasCreditsSpy: MockInstance<MeteringService['hasEnoughCredits']>;
 let incrementUsageSpy: MockInstance<MeteringService['incrementUsage']>;
 let batchIncrementUsagesSpy: MockInstance<
    MeteringService['batchIncrementUsages']
@@ -111,7 +111,7 @@ beforeEach(() => {
    generateContentMock.mockReset();
    toBase64DataUriMock.mockReset();
    googleAICtor.mockReset();
-    admitSpy = vi.spyOn(server.services.metering, 'reserveCreditsIfAffordable');
+    hasCreditsSpy = vi.spyOn(server.services.metering, 'hasEnoughCredits');
    incrementUsageSpy = vi.spyOn(server.services.metering, 'incrementUsage');
    batchIncrementUsagesSpy = vi.spyOn(
        server.services.metering,
@@ -167,7 +167,7 @@ describe('GeminiImageProvider.generate test_mode', () => {
        expect(result).toBe(
            'https://puter-sample-data.puter.site/image_example.png',
        );
-        expect(admitSpy).not.toHaveBeenCalled();
+        expect(hasCreditsSpy).not.toHaveBeenCalled();
        expect(generateContentMock).not.toHaveBeenCalled();
    });
 });
@@ -219,7 +219,7 @@ describe('GeminiImageProvider.generate argument validation', () => {
                legacyCode: 'bad_request',
                message: expect.stringContaining('Unsupported quality tier'),
            });
-            expect(admitSpy).not.toHaveBeenCalled();
+            expect(hasCreditsSpy).not.toHaveBeenCalled();
            expect(generateContentMock).not.toHaveBeenCalled();
        },
    );
@@ -427,7 +427,7 @@ describe('GeminiImageProvider.generate Flash path (generateContent)', () => {

    it('throws 402 BEFORE hitting Gemini when actor lacks credits', async () => {
        const provider = makeProvider();
-        admitSpy.mockResolvedValueOnce(null);
+        hasCreditsSpy.mockResolvedValueOnce(false);

        await expect(
            withTestActor(() =>
@@ -466,7 +466,7 @@ describe('GeminiImageProvider.generate Flash path (generateContent)', () => {
            actor,
        );

-        const [, estimate] = admitSpy.mock.calls[0]!;
+        const [, estimate] = hasCreditsSpy.mock.calls[0]!;
        expect(estimate).toBeGreaterThan(0);
        expect(heldDuringCall).toBe(Math.ceil(estimate));
        // The hold stays until the usage write lands.
@@ -643,7 +643,7 @@ describe('Gemini Nano Banana image generation', () => {
        const request = generateContentMock.mock.calls[0][0];
        expect(request.config.imageConfig.imageSize).toBe('1K');
        // Input + 1120 image tokens at $30/1M + 1000 text tokens at $7.50/1M.
-        expect(admitSpy).toHaveBeenCalledWith(expect.anything(), 4_194_450, undefined);
+        expect(hasCreditsSpy).toHaveBeenCalledWith(expect.anything(), 4_194_450);
        expect(batchIncrementUsagesSpy).toHaveBeenCalledWith(
            expect.anything(),
            expect.arrayContaining([