@camada/remix 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 camada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @camada/remix
+
+camada for [React Router](https://reactrouter.com) framework mode (the Remix lineage): enforces
+the tenant snapshot in a root server middleware (your ordered custom rules, then block, allow,
+challenge), serves a first-party proof-of-work challenge page and beacon, and records the
+outcomes your actions know (`track()`). Fails open by design — a camada outage or bug never
+5xxes your app.
+
+Not yet on npm — consumed via a `file:` dependency from a sibling checkout.
+
+## Quickstart
+
+```ts
+// app/root.tsx
+import { camada } from '@camada/remix';
+
+export const middleware = [camada()];   // reads CAMADA_KEY / CAMADA_INGEST_URL / CAMADA_SNAPSHOT_URL from process.env
+```
+
+```ts
+// app/routes.ts
+import { type RouteConfig, index, route } from '@react-router/dev/routes';
+
+export default [
+  index('routes/home.tsx'),
+  route('/_cam/*', 'routes/cam.tsx'),   // the beacon endpoints only run where a route exists
+] satisfies RouteConfig;
+```
+
+```ts
+// app/routes/cam.tsx
+import { camadaRoute } from '@camada/remix';
+
+export const { loader, action } = camadaRoute();
+```
+
+Env (printed by camada onboarding / `npm run seed` in dev):
+
+```
+CAMADA_KEY=<ingest_token>.<snap_token>
+CAMADA_INGEST_URL=http://localhost:8787        # dev only; defaults to production ingest
+```
+
+An app that reads its own config can pass the values instead:
+
+```ts
+export const middleware = [camada({ key: MY_KEY, ingestUrl: MY_INGEST })];
+```
+
+Server middleware is stable in React Router 8. On 7.9+ it is behind a future flag:
+
+```ts
+// react-router.config.ts
+export default { future: { v8_middleware: true } };
+```
+
+Without `CAMADA_KEY` the middleware is inert (one log line, no requests, no enforcement), so an
+unprovisioned environment behaves exactly as if camada were not installed.
+
+`camada()` and `camadaRoute()` share one engine per configuration — the same options object,
+or two that spell the same options — so the middleware and the route poll one snapshot and
+fill one event queue. Two mounts with different keys or URLs each get their own.
+
+## What it does per request
+
+1. Refreshes the snapshot off-path (lazy mode by default: a refresh is kicked when stale and
+   the request does not wait for it; `mode: 'timer'` polls on an unref'd interval and drains
+   the queue on exit for a long-lived Node server). Every poll and event batch carries
+   `x-camada-sdk: @camada/remix/<version>`, and polls ask for snapshot v5
+   (`x-camada-snapshot: 5`) — the container that carries your ordered custom rules.
+2. Resolves the client from the peer your server vouched for (see below), falling back to
+   `X-Forwarded-For` only under your tenant's trusted-proxy config. A bare header is never
+   trusted: without a vouched peer and a trusted-proxy config the ip is `null`, ip rules do not
+   fire, and the request is still captured.
+3. Runs your ordered custom rules, then the allow, block and challenge lists.
+4. **Block** → `403` with `x-block-reason` (and `x-block-rule` when a custom rule decided)
+   before `next()`; the event still ships, with `st: 403` and `blk: <reason>` so the analyst
+   counts SDK blocks apart from your own 403s.
+5. **Skip** → a skip rule or the allow list wins over a wider block.
+6. **Challenge** → a `403` proof-of-work page for HTML navigations, `403
+   {"error":"challenge_required"}` for anything else; `POST /__camada/challenge` verifies the
+   work, sets `_cch` and 302s back.
+7. Otherwise `next()` runs your loaders and actions, and the settled response ships one
+   batched, redacted event with its real status (Authorization and Cookie values never leave
+   the process; credential-looking query values are scrubbed — see `@camada/core`). A first
+   visit gets the `_sfp` session cookie, appended even to a `redirect()` whose headers are
+   immutable.
+
+## The peer
+
+React Router hands the middleware a `Request` and nothing about the socket, so out of the box
+this tap vouches for no address. A custom server knows the socket and can say so through
+`getLoadContext`:
+
+```ts
+// server.ts (Express)
+import { createRequestHandler } from '@react-router/express';
+import { RouterContextProvider } from 'react-router';
+import { camadaPeerContext } from '@camada/remix';
+
+app.all('*', createRequestHandler({
+  build,
+  getLoadContext(req) {
+    const context = new RouterContextProvider();
+    context.set(camadaPeerContext, req.socket.remoteAddress ?? null);   // the address Node vouches for, never a header
+    return context;
+  },
+}));
+```
+
+Behind a load balancer, set `CAMADA_TRUSTED_PROXY=hops:1` (or `cidrs:…`) — or the
+`trustedProxy` option — and `X-Forwarded-For` is read one hop behind that peer. Never put a
+header value in `camadaPeerContext`: that is the one address camada takes on faith.
+
+## Options
+
+| option | default | meaning |
+|---|---|---|
+| `key` | `env.CAMADA_KEY` | `<ingest_token>.<snap_token>`; without it the middleware is inert |
+| `ingestUrl` | `env.CAMADA_INGEST_URL` | ingest base; batches go to `<ingestUrl>/e` |
+| `snapshotUrl` | `<ingestUrl>/snapshot` | snapshot endpoint |
+| `trustedProxy` | server config | `none` / `vercel` / `hops:N` / `cidrs:a,b`, or the parsed object |
+| `challenge` | `true` | serve the proof-of-work page for `challenge` verdicts |
+| `challengePath` | `/__camada/challenge` | where that page posts its solution |
+| `snapshotVersion` | `5` | `4` drops the custom rules, `3` the allow/challenge sides too |
+| `scriptPath` | `/_cam/b.js` | where the first-party beacon script is served |
+| `fpPath` | `/_cam/fp` | where that script posts the beacon; keep it in `scriptPath`'s directory |
+| `mode` | `lazy` (or `timer`) | `timer` polls the snapshot on an unref'd interval (long-lived process); `lazy` refreshes it per request off-path. `CAMADA_SERVERLESS=1` forces `lazy` |
+| `env` | `process.env` | overrides the process env (tests, and apps that read config themselves) |
+
+`CAMADA_CHALLENGE=0` in the env switches the challenge off without a code change.
+
+`CAMADA_DISABLED=1` in the env switches everything off, checked per request.
+
+## The first-party beacon
+
+Bots that never run JavaScript are the cheapest to catch. Put the tag in the pages you render
+and the middleware does the rest. The helper returns markup, so render it through a wrapper
+at the end of `<body>` — it is part of the server-rendered document, and the browser runs it
+on parse (an element cannot be dangerously-set inside `<head>` next to `<Meta />`):
+
+```tsx
+// app/root.tsx
+import { Meta, Links, Scripts, useRouteLoaderData } from 'react-router';
+import { camada, scriptTag } from '@camada/remix';
+import type { Route } from './+types/root';
+
+export const middleware = [camada()];
+export const loader = ({ context }: Route.LoaderArgs) => ({ beacon: scriptTag(context) });
+
+export function Layout({ children }: { children: React.ReactNode }) {
+  const { beacon } = useRouteLoaderData<typeof loader>('root') ?? { beacon: '' };
+  return (
+    <html>
+      <head><Meta /><Links /></head>
+      <body>
+        {children}
+        <Scripts />
+        <div hidden dangerouslySetInnerHTML={{ __html: beacon }} />
+      </body>
+    </html>
+  );
+}
+```
+
+`scriptTag(context)` returns `<script src="/_cam/b.js?r=<rid>" async></script>` — the `rid` is
+this request's event id, so the analyst joins the beacon to the page view. The middleware
+serves the script at `GET /_cam/b.js` (cacheable, 1 h) and relays `POST /_cam/fp` (≤ 32 KB,
+answers 204) onto the event batch as a `sig: 1` row stamped with the client ip camada resolved —
+never the one the body claims. Both endpoints sit behind the verdict: a blocked client gets 403
+there too. The tag is `''` when camada is off for the request or the project turned the beacon
+off in its settings, and the endpoints stand down with it.
+
+React Router runs middleware only for matched routes, so `/_cam/*` needs a route to exist:
+that is what `route('/_cam/*', 'routes/cam.tsx')` and `camadaRoute()` are for. With the root
+middleware mounted it answers first and the route's loader and action are the fallback (a
+middleware mounted lower, or none at all); they re-run the verdict, so a blocked client is
+403'd there as well. A custom `scriptPath` / `fpPath` must share a directory (the script derives
+the post path from its own `src`) and the route must cover it.
+
+## App-context events
+
+The wire shows a `POST /login`; only your action knows whether it failed. Tell camada:
+
+```ts
+// app/routes/login.tsx
+import { track } from '@camada/remix';
+import type { Route } from './+types/login';
+
+export async function action({ request, context }: Route.ActionArgs) {
+  const form = await request.formData();
+  const user = String(form.get('email'));
+  const ok = await signIn(user, String(form.get('password')));
+  if (!ok) track(context, 'login_failed', { user });   // await optional
+  return ok ? redirect('/') : data({ error: 'Invalid credentials' }, { status: 401 });
+}
+```
+
+`track(context, event, { user? })` ships `{ et, uid, rid, sid, ip, ts }` joined to this
+request's event. The user identifier is HMAC-hashed in-process with the ingest token — the raw
+value never leaves the process. It never throws and is a no-op where the middleware did not
+run. The event name is free-form; the analyst's rules read this vocabulary:
+
+| event | when |
+|---|---|
+| `login_failed` / `login_succeeded` | a credential check settled |
+| `signup` | an account was created |
+| `password_reset` | a reset was requested |
+| `mfa_failed` | a second factor was rejected |
+| `payment_failed` / `payment_succeeded` | a charge settled |
+| `coupon_failed` | a promo code was rejected |
+
+## What this tap can see
+
+The in-app position: the beacon, the client hints and headers the request carries, the real
+response status, the `_sfp` session, and the outcomes your actions report through `track()`.
+What it cannot see is the connection. React Router vouches for nothing below the `Request` —
+no socket address, no ASN, country, TLS fingerprint or client protocol — so those come only
+from what your server puts in `camadaPeerContext` (the address) and from a trusted-proxy
+config (`X-Forwarded-For`). ASN, country and `tlsx` rules do not fire at this tap; the analyst
+knows that from the tap's capability mask (`sdk-remix`) and never scores their absence as
+evidence. Header order is normalised by the `Headers` API before camada sees it, so the
+raw-wire-order signal is not available here either.
+
+## Fail open
+
+Every entry point runs inside camada's guard. A dead ingest, a corrupt snapshot, a bug in this
+package, a context that is not a `RouterContextProvider`: telemetry is lost, the request is not.

package/dist/index.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  camada: () => camada,
+  camadaPeerContext: () => camadaPeerContext,
+  camadaRoute: () => camadaRoute,
+  resetCamada: () => resetCamada,
+  scriptTag: () => scriptTag,
+  track: () => track
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/camada.ts
+var import_iife_string = __toESM(require("@camada/browser/iife-string"), 1);
+var import_core2 = require("@camada/core");
+var import_fetch2 = require("@camada/core/fetch");
+
+// src/context.ts
+var import_react_router = require("react-router");
+var import_core = require("@camada/core");
+var import_fetch = require("@camada/core/fetch");
+var camadaContext = (0, import_react_router.createContext)(null);
+var camadaPeerContext = (0, import_react_router.createContext)(null);
+var readSlot = (context) => (0, import_core.guarded)(() => context.get(camadaContext) ?? void 0, void 0);
+var track = (context, event, data) => (0, import_fetch.track)(readSlot(context), event, data);
+var scriptTag = (context) => (0, import_fetch.scriptTag)(readSlot(context));
+
+// package.json
+var name = "@camada/remix";
+var version = "0.1.0";
+
+// src/version.ts
+var SDK_ID = `${name}/${version}`;
+
+// src/camada.ts
+var instances = /* @__PURE__ */ new Set();
+var byKey = /* @__PURE__ */ new Map();
+var sortedJson = (v) => JSON.stringify(v, (_, x) => x && typeof x === "object" && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : x);
+function instanceFor(opts = {}) {
+  const { fetchImpl, ...serialisable } = opts;
+  const key = sortedJson(serialisable);
+  let bucket = byKey.get(fetchImpl);
+  if (!bucket) byKey.set(fetchImpl, bucket = /* @__PURE__ */ new Map());
+  let cam = bucket.get(key);
+  if (!cam) {
+    cam = (0, import_fetch2.createFetchCamada)({ tap: import_core2.TAP_REMIX, sdk: SDK_ID, iife: import_iife_string.default }, opts);
+    bucket.set(key, cam);
+    instances.add(cam);
+  }
+  return cam;
+}
+function resetCamada() {
+  for (const cam of instances) cam.reset();
+}
+function requestContext(context) {
+  return {
+    peer: (0, import_core2.guarded)(() => context.get(camadaPeerContext), null),
+    env: globalThis.process?.env
+  };
+}
+function camada(opts = {}) {
+  const cam = instanceFor(opts);
+  return async ({ request, context }, next) => {
+    const r = await cam.before(request, requestContext(context));
+    if (!r) return next();
+    if (r.response) return r.response;
+    (0, import_core2.guarded)(() => context.set(camadaContext, r.vars), void 0);
+    let res;
+    try {
+      res = await next();
+    } catch (err) {
+      if (err instanceof Response) {
+        cam.after(request, r.vars, err.status);
+        throw r.vars.sessionCookie ? (0, import_fetch2.withSetCookie)(err, r.vars.sessionCookie) : err;
+      }
+      cam.after(request, r.vars, 500);
+      throw err;
+    }
+    cam.after(request, r.vars, res.status);
+    return r.vars.sessionCookie ? (0, import_fetch2.withSetCookie)(res, r.vars.sessionCookie) : res;
+  };
+}
+
+// src/route.ts
+function camadaRoute(opts = {}) {
+  const cam = instanceFor(opts);
+  const answer = async ({ request, context }) => {
+    const r = await cam.before(request, requestContext(context));
+    return r?.response ?? new Response(null, { status: 404 });
+  };
+  return { loader: answer, action: answer };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  camada,
+  camadaPeerContext,
+  camadaRoute,
+  resetCamada,
+  scriptTag,
+  track
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/camada.ts","../src/context.ts","../package.json","../src/version.ts","../src/route.ts"],"sourcesContent":["// @camada/remix — the install for a React Router framework-mode (Remix) app:\n//   export const middleware = [camada()];              // app/root.tsx; env: CAMADA_KEY (+ CAMADA_INGEST_URL in dev)\n//   route('/_cam/*', 'routes/cam.tsx')                 // routes.ts; the file re-exports camadaRoute()\n//   scriptTag(context)                                 // in a loader: the first-party beacon tag\n//   track(context, 'login_failed', { user })           // in an action: an outcome the wire cannot show\nexport { camada, resetCamada, type CamadaRemixOptions, type CamadaRemixVars } from './camada.js';\nexport { camadaRoute } from './route.js';\nexport { track, scriptTag, camadaPeerContext } from './context.js';\n","// @camada/remix — the root server middleware for React Router framework mode (SDK-G04):\n//   export const middleware = [camada()];   // app/root.tsx\n// A thin binding over @camada/core/fetch: the peer is whatever a custom server put in\n// `camadaPeerContext` (React Router itself vouches for no socket), the env is process.env, and\n// there is no waitUntil — the host is a long-lived Node server or an edge runtime that keeps\n// its own isolate open. A camada bug, a dead ingest or a corrupt snapshot costs telemetry,\n// never the app's response.\nimport iife from '@camada/browser/iife-string';\nimport { guarded, TAP_REMIX } from '@camada/core';\nimport { createFetchCamada, withSetCookie, type FetchCamada, type FetchCamadaOptions, type FetchRequestContext, type FetchVars } from '@camada/core/fetch';\nimport type { MiddlewareFunction } from 'react-router';\nimport { camadaContext, camadaPeerContext, type RouterContext } from './context.js';\nimport { SDK_ID } from './version.js';\n\nexport type CamadaRemixOptions = FetchCamadaOptions;\nexport type CamadaRemixVars = FetchVars;\n\n// camada() and camadaRoute() must see one engine for the same options, or the route would poll\n// and enforce a second copy of the tenant's snapshot: an instance is found by its serialisable\n// options (keys sorted, so two modules spelling them in a different order agree); fetchImpl\n// cannot be stringified, so it keys a bucket by identity.\nconst instances = new Set<FetchCamada>();\nconst byKey = new Map<typeof fetch | undefined, Map<string, FetchCamada>>();\n\n// Sorts the keys of every object on the way in, so key order never splits one configuration in two.\nconst sortedJson = (v: unknown): string =>\n  JSON.stringify(v, (_, x: unknown) => (x && typeof x === 'object' && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) : x));\n\nexport function instanceFor(opts: CamadaRemixOptions = {}): FetchCamada {\n  const { fetchImpl, ...serialisable } = opts;\n  const key = sortedJson(serialisable);\n  let bucket = byKey.get(fetchImpl);\n  if (!bucket) byKey.set(fetchImpl, (bucket = new Map()));\n  let cam = bucket.get(key);\n  if (!cam) {\n    cam = createFetchCamada({ tap: TAP_REMIX, sdk: SDK_ID, iife }, opts);\n    bucket.set(key, cam);\n    instances.add(cam);\n  }\n  return cam;\n}\n\n/** Test/reset hook: stops and drops every engine this module created; the instances stay wired and rebuild lazily. */\nexport function resetCamada(): void {\n  for (const cam of instances) cam.reset();\n}\n\n/** What the host can vouch for: the peer a custom server set, and the process env. The peer read\n *  is guarded — a 7.9 app without the middleware flag hands a plain object; an edge runtime has no process. */\nexport function requestContext(context: RouterContext): FetchRequestContext {\n  return {\n    peer: guarded(() => context.get(camadaPeerContext), null),\n    env: globalThis.process?.env,\n  };\n}\n\nexport function camada(opts: CamadaRemixOptions = {}): MiddlewareFunction<Response> {\n  const cam = instanceFor(opts);\n  return async ({ request, context }, next) => {\n    const r = await cam.before(request, requestContext(context));\n    if (!r) return next();\n    if (r.response) return r.response;   // block, challenge, verify, beacon: answered without the app\n    guarded(() => context.set(camadaContext, r.vars), undefined);\n    let res: Response;\n    try {\n      res = await next();\n    } catch (err) {\n      // A thrown Response (a redirect from a downstream middleware) is the answer, so it carries\n      // the status and the cookie; anything else lands in the router's error boundary as a 500.\n      if (err instanceof Response) {\n        cam.after(request, r.vars, err.status);\n        throw r.vars.sessionCookie ? withSetCookie(err, r.vars.sessionCookie) : err;\n      }\n      cam.after(request, r.vars, 500);\n      throw err;\n    }\n    cam.after(request, r.vars, res.status);\n    return r.vars.sessionCookie ? withSetCookie(res, r.vars.sessionCookie) : res;\n  };\n}\n","// Per-request state the middleware leaves on React Router's context for the two helpers an app\n// calls from its own loaders and actions: `scriptTag(context)` (the beacon tag) and\n// `track(context, event, data)` (an app-context outcome). When the middleware did not run for\n// this request (no key, CAMADA_DISABLED, or a request it answered itself) the slot is empty and\n// both helpers stand down.\nimport { createContext, type RouterContextProvider } from 'react-router';\nimport { guarded } from '@camada/core';\nimport { track as coreTrack, scriptTag as coreScriptTag, type FetchVars } from '@camada/core/fetch';\n\n// Defaults are null, not undefined: React Router's `get()` throws on a context that has neither\n// a value nor a default, and the helpers must stand down silently where the middleware did not run.\n/** The vars the middleware kept for this request; null where it did not run. Private to the package: track() and scriptTag() are the API. */\nexport const camadaContext = createContext<FetchVars | null>(null);\n\n/** The socket address a custom server vouches for (set from `getLoadContext`); null = nothing vouched. */\nexport const camadaPeerContext = createContext<string | null>(null);\n\n/** Loaders, actions and middleware all receive the same read-only provider. */\nexport type RouterContext = Readonly<RouterContextProvider>;\n\nconst readSlot = (context: RouterContext): FetchVars | undefined => guarded(() => context.get(camadaContext) ?? undefined, undefined);\n\n/**\n * Records an outcome the app knows and the wire cannot show: `login_failed`, `login_succeeded`,\n * `signup`, `password_reset`, `mfa_failed`, `payment_failed`, `payment_succeeded`, `coupon_failed`\n * (free-form; that vocabulary is what the analyst's rules read). Joined to this request's event\n * through its rid and session; the user identifier is HMAC-hashed in-process. Never throws,\n * never rejects, and is a no-op where the middleware did not run.\n */\nexport const track = (context: RouterContext, event: string, data?: { user?: string }): Promise<void> => coreTrack(readSlot(context), event, data);\n\n/** The `<script>` tag for an HTML response — `''` when camada is off for this request or the tenant turned the beacon off. */\nexport const scriptTag = (context: RouterContext): string => coreScriptTag(readSlot(context));\n","{\n  \"name\": \"@camada/remix\",\n  \"version\": \"0.1.0\",\n  \"license\": \"MIT\",\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=20\"\n  },\n  \"files\": [\n    \"dist\",\n    \"README.md\",\n    \"LICENSE\"\n  ],\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"vitest run\",\n    \"check\": \"tsc --noEmit\"\n  },\n  \"description\": \"camada SDK for React Router framework mode (Remix): snapshot enforcement in a root middleware, first-party challenge and beacon route, track() outcomes\",\n  \"exports\": {\n    \".\": {\n      \"types\": \"./dist/index.d.ts\",\n      \"import\": \"./dist/index.js\",\n      \"require\": \"./dist/index.cjs\"\n    }\n  },\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"dependencies\": {\n    \"@camada/core\": \"file:../camada-core\",\n    \"@camada/browser\": \"file:../camada-browser\"\n  },\n  \"peerDependencies\": {\n    \"react-router\": \">=7.9\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^22.10.0\",\n    \"react-router\": \"^8.3.1\",\n    \"tsup\": \"^8.3.5\",\n    \"typescript\": \"^5.7.2\",\n    \"vitest\": \"^3.0.0\"\n  }\n}\n","// The SDK's wire identity (SDK-03): x-camada-sdk: <package>/<version>. Named JSON imports are\n// inlined and tree-shaken by tsup at build, so dist carries two literals — no runtime fs read.\nimport { name, version } from '../package.json';\nexport const SDK_ID = `${name}/${version}`;\n","// The resource route for the beacon endpoints (routes.ts: route('/_cam/*', 'routes/cam.tsx')).\n// React Router runs middleware only for a matched route, so without a route under /_cam/* the\n// root middleware never sees the script or the relay and the router 404s them — the same reason\n// @camada/next has camadaRoute(). before() re-runs the verdict, so a blocked client gets its\n// 403 here too, and with the root middleware mounted it answers first and this never runs.\nimport type { ActionFunctionArgs, LoaderFunctionArgs } from 'react-router';\nimport { instanceFor, requestContext, type CamadaRemixOptions } from './camada.js';\n\ntype Handler<A> = (args: A) => Promise<Response>;\n\nexport function camadaRoute(opts: CamadaRemixOptions = {}): { loader: Handler<LoaderFunctionArgs>; action: Handler<ActionFunctionArgs> } {\n  const cam = instanceFor(opts);\n  const answer: Handler<LoaderFunctionArgs | ActionFunctionArgs> = async ({ request, context }) => {\n    const r = await cam.before(request, requestContext(context));\n    return r?.response ?? new Response(null, { status: 404 });   // not a beacon path, or camada inert: nothing to serve\n  };\n  return { loader: answer, action: answer };\n}\n"],"mappings":"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","names":["import_core","import_fetch","coreTrack","coreScriptTag","iife"]}

package/dist/index.d.cts

@@ -0,0 +1,34 @@
+import { FetchCamadaOptions, FetchVars } from '@camada/core/fetch';
+import * as react_router from 'react-router';
+import { RouterContextProvider, MiddlewareFunction, LoaderFunctionArgs, ActionFunctionArgs } from 'react-router';
+
+/** The socket address a custom server vouches for (set from `getLoadContext`); null = nothing vouched. */
+declare const camadaPeerContext: react_router.RouterContext<string | null>;
+/** Loaders, actions and middleware all receive the same read-only provider. */
+type RouterContext = Readonly<RouterContextProvider>;
+/**
+ * Records an outcome the app knows and the wire cannot show: `login_failed`, `login_succeeded`,
+ * `signup`, `password_reset`, `mfa_failed`, `payment_failed`, `payment_succeeded`, `coupon_failed`
+ * (free-form; that vocabulary is what the analyst's rules read). Joined to this request's event
+ * through its rid and session; the user identifier is HMAC-hashed in-process. Never throws,
+ * never rejects, and is a no-op where the middleware did not run.
+ */
+declare const track: (context: RouterContext, event: string, data?: {
+    user?: string;
+}) => Promise<void>;
+/** The `<script>` tag for an HTML response — `''` when camada is off for this request or the tenant turned the beacon off. */
+declare const scriptTag: (context: RouterContext) => string;
+
+type CamadaRemixOptions = FetchCamadaOptions;
+type CamadaRemixVars = FetchVars;
+/** Test/reset hook: stops and drops every engine this module created; the instances stay wired and rebuild lazily. */
+declare function resetCamada(): void;
+declare function camada(opts?: CamadaRemixOptions): MiddlewareFunction<Response>;
+
+type Handler<A> = (args: A) => Promise<Response>;
+declare function camadaRoute(opts?: CamadaRemixOptions): {
+    loader: Handler<LoaderFunctionArgs>;
+    action: Handler<ActionFunctionArgs>;
+};
+
+export { type CamadaRemixOptions, type CamadaRemixVars, camada, camadaPeerContext, camadaRoute, resetCamada, scriptTag, track };

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { FetchCamadaOptions, FetchVars } from '@camada/core/fetch';
+import * as react_router from 'react-router';
+import { RouterContextProvider, MiddlewareFunction, LoaderFunctionArgs, ActionFunctionArgs } from 'react-router';
+
+/** The socket address a custom server vouches for (set from `getLoadContext`); null = nothing vouched. */
+declare const camadaPeerContext: react_router.RouterContext<string | null>;
+/** Loaders, actions and middleware all receive the same read-only provider. */
+type RouterContext = Readonly<RouterContextProvider>;
+/**
+ * Records an outcome the app knows and the wire cannot show: `login_failed`, `login_succeeded`,
+ * `signup`, `password_reset`, `mfa_failed`, `payment_failed`, `payment_succeeded`, `coupon_failed`
+ * (free-form; that vocabulary is what the analyst's rules read). Joined to this request's event
+ * through its rid and session; the user identifier is HMAC-hashed in-process. Never throws,
+ * never rejects, and is a no-op where the middleware did not run.
+ */
+declare const track: (context: RouterContext, event: string, data?: {
+    user?: string;
+}) => Promise<void>;
+/** The `<script>` tag for an HTML response — `''` when camada is off for this request or the tenant turned the beacon off. */
+declare const scriptTag: (context: RouterContext) => string;
+
+type CamadaRemixOptions = FetchCamadaOptions;
+type CamadaRemixVars = FetchVars;
+/** Test/reset hook: stops and drops every engine this module created; the instances stay wired and rebuild lazily. */
+declare function resetCamada(): void;
+declare function camada(opts?: CamadaRemixOptions): MiddlewareFunction<Response>;
+
+type Handler<A> = (args: A) => Promise<Response>;
+declare function camadaRoute(opts?: CamadaRemixOptions): {
+    loader: Handler<LoaderFunctionArgs>;
+    action: Handler<ActionFunctionArgs>;
+};
+
+export { type CamadaRemixOptions, type CamadaRemixVars, camada, camadaPeerContext, camadaRoute, resetCamada, scriptTag, track };

package/dist/index.js

@@ -0,0 +1,89 @@
+// src/camada.ts
+import iife from "@camada/browser/iife-string";
+import { guarded as guarded2, TAP_REMIX } from "@camada/core";
+import { createFetchCamada, withSetCookie } from "@camada/core/fetch";
+
+// src/context.ts
+import { createContext } from "react-router";
+import { guarded } from "@camada/core";
+import { track as coreTrack, scriptTag as coreScriptTag } from "@camada/core/fetch";
+var camadaContext = createContext(null);
+var camadaPeerContext = createContext(null);
+var readSlot = (context) => guarded(() => context.get(camadaContext) ?? void 0, void 0);
+var track = (context, event, data) => coreTrack(readSlot(context), event, data);
+var scriptTag = (context) => coreScriptTag(readSlot(context));
+
+// package.json
+var name = "@camada/remix";
+var version = "0.1.0";
+
+// src/version.ts
+var SDK_ID = `${name}/${version}`;
+
+// src/camada.ts
+var instances = /* @__PURE__ */ new Set();
+var byKey = /* @__PURE__ */ new Map();
+var sortedJson = (v) => JSON.stringify(v, (_, x) => x && typeof x === "object" && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : x);
+function instanceFor(opts = {}) {
+  const { fetchImpl, ...serialisable } = opts;
+  const key = sortedJson(serialisable);
+  let bucket = byKey.get(fetchImpl);
+  if (!bucket) byKey.set(fetchImpl, bucket = /* @__PURE__ */ new Map());
+  let cam = bucket.get(key);
+  if (!cam) {
+    cam = createFetchCamada({ tap: TAP_REMIX, sdk: SDK_ID, iife }, opts);
+    bucket.set(key, cam);
+    instances.add(cam);
+  }
+  return cam;
+}
+function resetCamada() {
+  for (const cam of instances) cam.reset();
+}
+function requestContext(context) {
+  return {
+    peer: guarded2(() => context.get(camadaPeerContext), null),
+    env: globalThis.process?.env
+  };
+}
+function camada(opts = {}) {
+  const cam = instanceFor(opts);
+  return async ({ request, context }, next) => {
+    const r = await cam.before(request, requestContext(context));
+    if (!r) return next();
+    if (r.response) return r.response;
+    guarded2(() => context.set(camadaContext, r.vars), void 0);
+    let res;
+    try {
+      res = await next();
+    } catch (err) {
+      if (err instanceof Response) {
+        cam.after(request, r.vars, err.status);
+        throw r.vars.sessionCookie ? withSetCookie(err, r.vars.sessionCookie) : err;
+      }
+      cam.after(request, r.vars, 500);
+      throw err;
+    }
+    cam.after(request, r.vars, res.status);
+    return r.vars.sessionCookie ? withSetCookie(res, r.vars.sessionCookie) : res;
+  };
+}
+
+// src/route.ts
+function camadaRoute(opts = {}) {
+  const cam = instanceFor(opts);
+  const answer = async ({ request, context }) => {
+    const r = await cam.before(request, requestContext(context));
+    return r?.response ?? new Response(null, { status: 404 });
+  };
+  return { loader: answer, action: answer };
+}
+export {
+  camada,
+  camadaPeerContext,
+  camadaRoute,
+  resetCamada,
+  scriptTag,
+  track
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/camada.ts","../src/context.ts","../package.json","../src/version.ts","../src/route.ts"],"sourcesContent":["// @camada/remix — the root server middleware for React Router framework mode (SDK-G04):\n//   export const middleware = [camada()];   // app/root.tsx\n// A thin binding over @camada/core/fetch: the peer is whatever a custom server put in\n// `camadaPeerContext` (React Router itself vouches for no socket), the env is process.env, and\n// there is no waitUntil — the host is a long-lived Node server or an edge runtime that keeps\n// its own isolate open. A camada bug, a dead ingest or a corrupt snapshot costs telemetry,\n// never the app's response.\nimport iife from '@camada/browser/iife-string';\nimport { guarded, TAP_REMIX } from '@camada/core';\nimport { createFetchCamada, withSetCookie, type FetchCamada, type FetchCamadaOptions, type FetchRequestContext, type FetchVars } from '@camada/core/fetch';\nimport type { MiddlewareFunction } from 'react-router';\nimport { camadaContext, camadaPeerContext, type RouterContext } from './context.js';\nimport { SDK_ID } from './version.js';\n\nexport type CamadaRemixOptions = FetchCamadaOptions;\nexport type CamadaRemixVars = FetchVars;\n\n// camada() and camadaRoute() must see one engine for the same options, or the route would poll\n// and enforce a second copy of the tenant's snapshot: an instance is found by its serialisable\n// options (keys sorted, so two modules spelling them in a different order agree); fetchImpl\n// cannot be stringified, so it keys a bucket by identity.\nconst instances = new Set<FetchCamada>();\nconst byKey = new Map<typeof fetch | undefined, Map<string, FetchCamada>>();\n\n// Sorts the keys of every object on the way in, so key order never splits one configuration in two.\nconst sortedJson = (v: unknown): string =>\n  JSON.stringify(v, (_, x: unknown) => (x && typeof x === 'object' && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) : x));\n\nexport function instanceFor(opts: CamadaRemixOptions = {}): FetchCamada {\n  const { fetchImpl, ...serialisable } = opts;\n  const key = sortedJson(serialisable);\n  let bucket = byKey.get(fetchImpl);\n  if (!bucket) byKey.set(fetchImpl, (bucket = new Map()));\n  let cam = bucket.get(key);\n  if (!cam) {\n    cam = createFetchCamada({ tap: TAP_REMIX, sdk: SDK_ID, iife }, opts);\n    bucket.set(key, cam);\n    instances.add(cam);\n  }\n  return cam;\n}\n\n/** Test/reset hook: stops and drops every engine this module created; the instances stay wired and rebuild lazily. */\nexport function resetCamada(): void {\n  for (const cam of instances) cam.reset();\n}\n\n/** What the host can vouch for: the peer a custom server set, and the process env. The peer read\n *  is guarded — a 7.9 app without the middleware flag hands a plain object; an edge runtime has no process. */\nexport function requestContext(context: RouterContext): FetchRequestContext {\n  return {\n    peer: guarded(() => context.get(camadaPeerContext), null),\n    env: globalThis.process?.env,\n  };\n}\n\nexport function camada(opts: CamadaRemixOptions = {}): MiddlewareFunction<Response> {\n  const cam = instanceFor(opts);\n  return async ({ request, context }, next) => {\n    const r = await cam.before(request, requestContext(context));\n    if (!r) return next();\n    if (r.response) return r.response;   // block, challenge, verify, beacon: answered without the app\n    guarded(() => context.set(camadaContext, r.vars), undefined);\n    let res: Response;\n    try {\n      res = await next();\n    } catch (err) {\n      // A thrown Response (a redirect from a downstream middleware) is the answer, so it carries\n      // the status and the cookie; anything else lands in the router's error boundary as a 500.\n      if (err instanceof Response) {\n        cam.after(request, r.vars, err.status);\n        throw r.vars.sessionCookie ? withSetCookie(err, r.vars.sessionCookie) : err;\n      }\n      cam.after(request, r.vars, 500);\n      throw err;\n    }\n    cam.after(request, r.vars, res.status);\n    return r.vars.sessionCookie ? withSetCookie(res, r.vars.sessionCookie) : res;\n  };\n}\n","// Per-request state the middleware leaves on React Router's context for the two helpers an app\n// calls from its own loaders and actions: `scriptTag(context)` (the beacon tag) and\n// `track(context, event, data)` (an app-context outcome). When the middleware did not run for\n// this request (no key, CAMADA_DISABLED, or a request it answered itself) the slot is empty and\n// both helpers stand down.\nimport { createContext, type RouterContextProvider } from 'react-router';\nimport { guarded } from '@camada/core';\nimport { track as coreTrack, scriptTag as coreScriptTag, type FetchVars } from '@camada/core/fetch';\n\n// Defaults are null, not undefined: React Router's `get()` throws on a context that has neither\n// a value nor a default, and the helpers must stand down silently where the middleware did not run.\n/** The vars the middleware kept for this request; null where it did not run. Private to the package: track() and scriptTag() are the API. */\nexport const camadaContext = createContext<FetchVars | null>(null);\n\n/** The socket address a custom server vouches for (set from `getLoadContext`); null = nothing vouched. */\nexport const camadaPeerContext = createContext<string | null>(null);\n\n/** Loaders, actions and middleware all receive the same read-only provider. */\nexport type RouterContext = Readonly<RouterContextProvider>;\n\nconst readSlot = (context: RouterContext): FetchVars | undefined => guarded(() => context.get(camadaContext) ?? undefined, undefined);\n\n/**\n * Records an outcome the app knows and the wire cannot show: `login_failed`, `login_succeeded`,\n * `signup`, `password_reset`, `mfa_failed`, `payment_failed`, `payment_succeeded`, `coupon_failed`\n * (free-form; that vocabulary is what the analyst's rules read). Joined to this request's event\n * through its rid and session; the user identifier is HMAC-hashed in-process. Never throws,\n * never rejects, and is a no-op where the middleware did not run.\n */\nexport const track = (context: RouterContext, event: string, data?: { user?: string }): Promise<void> => coreTrack(readSlot(context), event, data);\n\n/** The `<script>` tag for an HTML response — `''` when camada is off for this request or the tenant turned the beacon off. */\nexport const scriptTag = (context: RouterContext): string => coreScriptTag(readSlot(context));\n","{\n  \"name\": \"@camada/remix\",\n  \"version\": \"0.1.0\",\n  \"license\": \"MIT\",\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=20\"\n  },\n  \"files\": [\n    \"dist\",\n    \"README.md\",\n    \"LICENSE\"\n  ],\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"vitest run\",\n    \"check\": \"tsc --noEmit\"\n  },\n  \"description\": \"camada SDK for React Router framework mode (Remix): snapshot enforcement in a root middleware, first-party challenge and beacon route, track() outcomes\",\n  \"exports\": {\n    \".\": {\n      \"types\": \"./dist/index.d.ts\",\n      \"import\": \"./dist/index.js\",\n      \"require\": \"./dist/index.cjs\"\n    }\n  },\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"dependencies\": {\n    \"@camada/core\": \"file:../camada-core\",\n    \"@camada/browser\": \"file:../camada-browser\"\n  },\n  \"peerDependencies\": {\n    \"react-router\": \">=7.9\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^22.10.0\",\n    \"react-router\": \"^8.3.1\",\n    \"tsup\": \"^8.3.5\",\n    \"typescript\": \"^5.7.2\",\n    \"vitest\": \"^3.0.0\"\n  }\n}\n","// The SDK's wire identity (SDK-03): x-camada-sdk: <package>/<version>. Named JSON imports are\n// inlined and tree-shaken by tsup at build, so dist carries two literals — no runtime fs read.\nimport { name, version } from '../package.json';\nexport const SDK_ID = `${name}/${version}`;\n","// The resource route for the beacon endpoints (routes.ts: route('/_cam/*', 'routes/cam.tsx')).\n// React Router runs middleware only for a matched route, so without a route under /_cam/* the\n// root middleware never sees the script or the relay and the router 404s them — the same reason\n// @camada/next has camadaRoute(). before() re-runs the verdict, so a blocked client gets its\n// 403 here too, and with the root middleware mounted it answers first and this never runs.\nimport type { ActionFunctionArgs, LoaderFunctionArgs } from 'react-router';\nimport { instanceFor, requestContext, type CamadaRemixOptions } from './camada.js';\n\ntype Handler<A> = (args: A) => Promise<Response>;\n\nexport function camadaRoute(opts: CamadaRemixOptions = {}): { loader: Handler<LoaderFunctionArgs>; action: Handler<ActionFunctionArgs> } {\n  const cam = instanceFor(opts);\n  const answer: Handler<LoaderFunctionArgs | ActionFunctionArgs> = async ({ request, context }) => {\n    const r = await cam.before(request, requestContext(context));\n    return r?.response ?? new Response(null, { status: 404 });   // not a beacon path, or camada inert: nothing to serve\n  };\n  return { loader: answer, action: answer };\n}\n"],"mappings":"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","names":["guarded","guarded"]}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@camada/remix",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "description": "camada SDK for React Router framework mode (Remix): snapshot enforcement in a root middleware, first-party challenge and beacon route, track() outcomes",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@camada/core": "^0.3.0",
+    "@camada/browser": "^0.2.0"
+  },
+  "peerDependencies": {
+    "react-router": ">=7.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/camada-app/camada-remix.git"
+  },
+  "homepage": "https://github.com/camada-app/camada-remix#readme",
+  "bugs": {
+    "url": "https://github.com/camada-app/camada-remix/issues"
+  }
+}