@opendatalabs/vana-sdk 4.4.0 → 4.5.0

package/README.md

@@ -261,6 +261,49 @@ accepts write entries in `scopes`, but its scope part must be a concrete
 scope: this flow reads approved scopes back one at a time, so wildcards are
 rejected there for read and write alike.
 
+### PDPP grants
+
+Ask for PDPP data as **grants**: a registry `source_id` and the streams you
+want from it. The controller turns each stream into one scope key,
+`pdpp.<source>.<stream>`, and that key is what the request, the signed grant
+and your reads carry.
+
+```typescript
+export const vana = createDirectDataController({
+  // ...
+  source: "chatgpt",
+  grants: [
+    {
+      source_id: "https://registry.pdpp.dev/sources/chatgpt",
+      streams: ["conversations", "messages"],
+    },
+  ],
+});
+// Requests ["pdpp.chatgpt.conversations", "pdpp.chatgpt.messages"].
+
+await vana.readApprovedData({ requestId, scope: "pdpp.chatgpt.messages" });
+```
+
+- `grants` and `scopes` can be combined. The request is the union: your
+  `scopes` verbatim, then the derived keys that are not already in it.
+  Existing apps that pass only `scopes` are unchanged.
+- The `pdpp.` namespace is separate from legacy scopes. PDPP's ChatGPT
+  `conversations` stream is `pdpp.chatgpt.conversations`, not the legacy
+  `chatgpt.conversations`, and `pdpp.chatgpt.*` covers only PDPP streams.
+  A legacy `scopes` entry under `pdpp.` that is not a valid key is rejected.
+- The mapping is strict and never slugifies. `source_id` must be
+  `https://registry.pdpp.dev/sources/<source>`, and `<source>` and each stream
+  must be lowercase letters, digits and underscores, not starting with an
+  underscore. Anything else throws `InvalidPdppGrantError` when the controller
+  is created.
+- `pdppScopeKey(source_id, stream)`, `parsePdppScopeKey(key)` (`{ source_id,
+stream }` or `null`), `isPdppScopeKey(key)`, `pdppGrantsToScopes(grants)`
+  and `grantRequestScopes({ grants, scopes })` are exported from `/server`,
+  the root entry points and `@opendatalabs/vana-sdk/protocol/scopes`. Use them
+  rather than building keys by hand. Other implementations can check
+  themselves against the vectors in
+  [`src/protocol/fixtures/pdpp-scope-keys.json`](src/protocol/fixtures/pdpp-scope-keys.json).
+
 ### Backend controller
 
 ```typescript
@@ -457,6 +500,139 @@ pass the same explicit `idempotencyKey` on the retry to avoid a duplicate DCR.
 `react` is an optional peer dependency. The underlying
 `createDirectConnectFlow` store is also exported for non-React frontends.
 
+### Connect in Vana's in-page sheet
+
+Instead of a Vana tab, the person can approve in a sheet Vana draws over your
+page (it signs them in, shows the request, and finishes inside the sheet). The
+sheet is `presentation: "sheet"` of the same flow: the request, the status poll
+and the read are unchanged. The integration is two files.
+
+Backend: one catch-all route serves `config`, `request`, `status` and `data`,
+binding each request to the browser that created it. The controller decides
+what is requested (its `grants` and `scopes`, see [PDPP grants](#pdpp-grants));
+the browser never chooses.
+
+```ts
+// app/api/vana/[action]/route.ts
+import { createVanaConnectHandler } from "@opendatalabs/vana-sdk/server";
+import { vana } from "@/lib/vana"; // your createDirectDataController({ grants, ... })
+
+const handler = createVanaConnectHandler({
+  controller: vana,
+  returnUrl: `${process.env.APP_URL}/connect/return`,
+  clientId: "my-app", // the embed client id Vana Account registered for your origin
+  // Recommended in production: only your signed-in users create requests.
+  session: async (request) => (await getSession(request))?.userId ?? null,
+});
+export { handler as GET, handler as POST };
+```
+
+The handler reports the Vana Account origin from the controller's `env`
+(`account.vana.org` for `production`, `account-dev.vana.org` for `dev`), so a
+dev app never frames production.
+
+Frontend:
+
+```tsx
+"use client";
+import { useVanaConnect } from "@opendatalabs/vana-sdk/react";
+
+export function ConnectButton() {
+  const { state, start } = useVanaConnect<MyData>({ endpoint: "/api/vana" });
+  if (state.type === "done") return <Result data={state.result.data} />;
+  return (
+    <>
+      <button
+        disabled={
+          state.type === "creating" || state.type === "awaiting_approval"
+        }
+        onClick={start}
+      >
+        Connect with Vana
+      </button>
+      {state.type === "awaiting_approval" && state.popupBlocked && (
+        // The sheet could not run here (state.sheetUnavailable says why).
+        <a href={state.request.approvalUrl} target="_blank" rel="noreferrer">
+          Open Vana
+        </a>
+      )}
+    </>
+  );
+}
+```
+
+- While the sheet is up, `state.sheet` reports `completion` (`in_browser` or
+  `remote_collect`) once the person approves, coarse `progress`
+  (`collecting`, `writing`), and any `error` it is showing.
+- **Approval is not delivery.** The sheet's `connected` event (and
+  `state.sheet.completion`) means the person approved; the data may still be
+  collecting. The flow reaches `done` only when your backend's status poll
+  says the request is readable and the read succeeds, and `error` when the
+  poll reports `denied`, `expired` or `completed` or the read fails. The sheet
+  sends no terminal event of its own; its events only make the flow poll
+  sooner.
+- Closing the sheet before approving returns to `idle`. Closing it after
+  approving keeps polling, since the data may still be readable.
+- If the frame cannot run (`frame_blocked`, `origin_not_registered`,
+  `incompatible_version`), the flow falls back to the tab presentation with
+  `popupBlocked: true`, so the "Open approval" link above still finishes it.
+  `origin_not_registered` arrives at once: the launcher asks Vana
+  (`GET <account>/api/embed/connect/client`, no credentials) alongside
+  framing. `vana_unavailable` means Vana's own side is down or misconfigured;
+  the sheet stays open and says so.
+- The partner reads; it cannot write through the sheet. Pass
+  `sheet: { closeAfterDoneMs: null }` to leave the sheet open after the read.
+- If your page sets a CSP, allow the frame and the client check:
+  `vanaConnectCsp(env)` from `/server` (or `/connect/protocol`) returns
+  `{ "frame-src": [accountOrigin], "connect-src": [accountOrigin] }`. It has
+  no default environment.
+- `createVanaConnectHandler` takes `session` to bind requests to your own
+  signed-in user (recommended: without it anyone who loads your page can
+  create requests as your app), `createOptions` for per-request create input
+  (questions, owner), and `read` to replace the default `readApprovedData`.
+  Use `toNodeHandler(handler)` for Express or plain `http`.
+- Creating a request is rate limited. The default, `createMemoryRateLimit()`,
+  allows 10 creates a minute per client IP and per session, in memory. It is
+  not production-grade (each instance counts alone, and the IP comes from
+  proxy headers): pass `rateLimit` backed by a shared store, or `false` when
+  a limiter already sits in front of the route. A refusal is
+  `429 rate_limited` with `Retry-After`.
+
+Choosing the Vana Account origin yourself (a custom flow, or preview deploys
+of Vana Account) goes through `resolveVanaAccountOrigin`; never match origins
+with your own pattern. It returns the environment's origin unless overrides
+are switched on for this build and the override is exactly an `https` origin
+on your allowlist:
+
+```ts
+import {
+  parseOriginAllowlist,
+  resolveVanaAccountOrigin,
+} from "@opendatalabs/vana-sdk/connect";
+
+const accountOrigin = resolveVanaAccountOrigin({
+  env: "dev",
+  override: new URLSearchParams(location.search).get("vana_account"),
+  previewOrigins: parseOriginAllowlist(
+    process.env.NEXT_PUBLIC_VANA_ACCOUNT_PREVIEW_ORIGINS,
+  ),
+  // From build-time config, never the request. Off in production.
+  allowOverride: process.env.NEXT_PUBLIC_DEPLOY_ENV === "preview",
+});
+```
+
+`createDirectConnectFlow` and the launcher take that origin (or an `env`)
+explicitly; neither falls back to production.
+
+Lower-level pieces: `createDirectConnectFlow(transports, { presentation:
+"sheet", sheet: { clientId, appName, accountOrigin } })` with an
+`authorizeRequest` transport backed by
+`controller.authorizeRequestRead(requestId)`; the launcher itself
+(`@opendatalabs/vana-sdk/connect`); and the zero-dependency message protocol
+(`@opendatalabs/vana-sdk/connect/protocol`). A backend in another language
+implements the [connect wire contract](./src/connect/WIRE_CONTRACT.md), which has test
+vectors.
+
 ### Test with large sample data
 
 When testing with realistic exports, use the public fixture catalog in

package/dist/connect/account-origin.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var account_origin_exports = {};
+__export(account_origin_exports, {
+  parseOriginAllowlist: () => parseOriginAllowlist,
+  resolveVanaAccountOrigin: () => resolveVanaAccountOrigin
+});
+module.exports = __toCommonJS(account_origin_exports);
+var import_protocol = require("./protocol");
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+const HOSTNAME = /^(?:\[[0-9a-f:.]+\]|[a-z0-9-]+(?:\.[a-z0-9-]+)*)$/;
+function exactOrigin(value, protocol) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  return url.protocol === protocol && url.origin === value && HOSTNAME.test(url.hostname) ? value : null;
+}
+function parseOriginAllowlist(csv) {
+  if (!csv) return [];
+  const origins = [];
+  for (const entry of csv.split(",")) {
+    const origin = exactOrigin(entry.trim(), "https:");
+    if (origin && !origins.includes(origin)) origins.push(origin);
+  }
+  return origins;
+}
+function resolveVanaAccountOrigin(input) {
+  if (input.env !== "production" && input.env !== "dev") {
+    throw new TypeError('env must be "production" or "dev"');
+  }
+  const fallback = import_protocol.VANA_ACCOUNT_ORIGINS[input.env];
+  const { override } = input;
+  if (input.allowOverride !== true || typeof override !== "string") {
+    return fallback;
+  }
+  const https = exactOrigin(override, "https:");
+  if (https && (input.previewOrigins ?? []).includes(https)) {
+    return https;
+  }
+  if (input.allowLocal === true) {
+    const local = exactOrigin(override, "http:");
+    if (local && LOOPBACK_HOSTS.has(new URL(local).hostname)) {
+      return local;
+    }
+  }
+  return fallback;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseOriginAllowlist,
+  resolveVanaAccountOrigin
+});
+//# sourceMappingURL=account-origin.cjs.map

package/dist/connect/account-origin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/connect/account-origin.ts"],"sourcesContent":["/**\n * Which Vana Account origin serves the connect sheet.\n *\n * @remarks\n * The sheet origin decides who the person signs in to and who receives the\n * partner's request capability, so it must never come from a pattern the\n * page URL can satisfy. {@link resolveVanaAccountOrigin} returns the\n * environment's Vana Account origin and accepts an override only when the\n * caller switched overrides on and the override is an exact origin from an\n * explicit allowlist. There is deliberately no pattern or wildcard option.\n *\n * Zero-dependency and browser-safe, like the protocol it builds on.\n *\n * @category Connect\n * @module connect/account-origin\n */\n\nimport { VANA_ACCOUNT_ORIGINS, type VanaConnectEnv } from \"./protocol\";\n\n/** Input for {@link resolveVanaAccountOrigin}. */\nexport interface ResolveVanaAccountOriginInput {\n  /** The deployment environment the app talks to. Required: there is no default. */\n  env: VanaConnectEnv;\n  /**\n   * A requested Account origin, typically read from a query parameter on a\n   * preview deploy. Untrusted. Ignored unless {@link allowOverride} is true.\n   */\n  override?: string | null;\n  /**\n   * Exact `https` origins (`https://host[:port]`, no path, no trailing slash)\n   * an override may name. Build it with {@link parseOriginAllowlist}. Entries\n   * that are not exact https origins never match.\n   */\n  previewOrigins?: readonly string[];\n  /**\n   * Whether this build honours an override at all. Decide it from build-time\n   * configuration (a non-production deploy), never from the request. Keep it\n   * `false` in production.\n   */\n  allowOverride: boolean;\n  /**\n   * Also accept an exact `http` loopback origin (`localhost`, `127.0.0.1`,\n   * `[::1]`, any port) without listing it, for a locally run Vana Account.\n   * Only applies when {@link allowOverride} is true. Defaults to `false`.\n   */\n  allowLocal?: boolean;\n}\n\nconst LOOPBACK_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"[::1]\"]);\n/** DNS labels (punycode included) or a bracketed IPv6 literal; no wildcards. */\nconst HOSTNAME = /^(?:\\[[0-9a-f:.]+\\]|[a-z0-9-]+(?:\\.[a-z0-9-]+)*)$/;\n\n/** `value` itself when it is a bare origin with `protocol`, else `null`. */\nfunction exactOrigin(\n  value: string,\n  protocol: \"https:\" | \"http:\",\n): string | null {\n  let url: URL;\n  try {\n    url = new URL(value);\n  } catch {\n    return null;\n  }\n  // `url.origin === value` rejects paths, queries, fragments, credentials,\n  // trailing slashes and any spelling the URL parser would rewrite.\n  return url.protocol === protocol &&\n    url.origin === value &&\n    HOSTNAME.test(url.hostname)\n    ? value\n    : null;\n}\n\n/**\n * Parse a comma-separated allowlist of exact `https` origins.\n *\n * @remarks\n * Whitespace around entries is trimmed. An entry that is not an exact\n * `https://host[:port]` origin (a path, a trailing slash, `http:`, a\n * wildcard such as `https://*.vercel.app`) is dropped, so a typo narrows\n * the list instead of widening it.\n *\n * @example\n * ```typescript\n * parseOriginAllowlist(process.env.VANA_ACCOUNT_PREVIEW_ORIGINS);\n * // [\"https://account-git-my-branch.vercel.app\"]\n * ```\n *\n * @param csv - The raw list, for example an environment variable.\n * @returns The exact https origins, deduplicated, in order.\n */\nexport function parseOriginAllowlist(csv: string | null | undefined): string[] {\n  if (!csv) return [];\n  const origins: string[] = [];\n  for (const entry of csv.split(\",\")) {\n    const origin = exactOrigin(entry.trim(), \"https:\");\n    if (origin && !origins.includes(origin)) origins.push(origin);\n  }\n  return origins;\n}\n\n/**\n * Resolve the Vana Account origin that serves the connect sheet.\n *\n * @remarks\n * Returns `VANA_ACCOUNT_ORIGINS[env]` unless `allowOverride` is true and\n * `override` is exactly one of `previewOrigins` (an `https` origin), or,\n * with `allowLocal`, exactly an `http` loopback origin. Anything else (a\n * path, a different scheme, a near-miss host, a lookalike) falls back to the\n * environment's origin. Matching is exact string equality: no patterns, no\n * suffixes, no normalization that could widen a match.\n *\n * @example\n * ```typescript\n * const accountOrigin = resolveVanaAccountOrigin({\n *   env: \"dev\",\n *   override: new URLSearchParams(location.search).get(\"vana_account\"),\n *   previewOrigins: parseOriginAllowlist(\n *     process.env.NEXT_PUBLIC_VANA_ACCOUNT_PREVIEW_ORIGINS,\n *   ),\n *   allowOverride: process.env.NEXT_PUBLIC_DEPLOY_ENV === \"preview\",\n * });\n * ```\n *\n * @param input - Environment, untrusted override, allowlist and switches.\n * @returns A bare Vana Account origin.\n * @throws TypeError when `env` is not `\"production\"` or `\"dev\"`.\n */\nexport function resolveVanaAccountOrigin(\n  input: ResolveVanaAccountOriginInput,\n): string {\n  if (input.env !== \"production\" && input.env !== \"dev\") {\n    throw new TypeError('env must be \"production\" or \"dev\"');\n  }\n  const fallback: string = VANA_ACCOUNT_ORIGINS[input.env];\n  const { override } = input;\n  if (input.allowOverride !== true || typeof override !== \"string\") {\n    return fallback;\n  }\n  const https = exactOrigin(override, \"https:\");\n  if (https && (input.previewOrigins ?? []).includes(https)) {\n    return https;\n  }\n  if (input.allowLocal === true) {\n    const local = exactOrigin(override, \"http:\");\n    if (local && LOOPBACK_HOSTS.has(new URL(local).hostname)) {\n      return local;\n    }\n  }\n  return fallback;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,sBAA0D;AA+B1D,MAAM,iBAAiB,oBAAI,IAAI,CAAC,aAAa,aAAa,OAAO,CAAC;AAElE,MAAM,WAAW;AAGjB,SAAS,YACP,OACA,UACe;AACf,MAAI;AACJ,MAAI;AACF,UAAM,IAAI,IAAI,KAAK;AAAA,EACrB,QAAQ;AACN,WAAO;AAAA,EACT;AAGA,SAAO,IAAI,aAAa,YACtB,IAAI,WAAW,SACf,SAAS,KAAK,IAAI,QAAQ,IACxB,QACA;AACN;AAoBO,SAAS,qBAAqB,KAA0C;AAC7E,MAAI,CAAC,IAAK,QAAO,CAAC;AAClB,QAAM,UAAoB,CAAC;AAC3B,aAAW,SAAS,IAAI,MAAM,GAAG,GAAG;AAClC,UAAM,SAAS,YAAY,MAAM,KAAK,GAAG,QAAQ;AACjD,QAAI,UAAU,CAAC,QAAQ,SAAS,MAAM,EAAG,SAAQ,KAAK,MAAM;AAAA,EAC9D;AACA,SAAO;AACT;AA6BO,SAAS,yBACd,OACQ;AACR,MAAI,MAAM,QAAQ,gBAAgB,MAAM,QAAQ,OAAO;AACrD,UAAM,IAAI,UAAU,mCAAmC;AAAA,EACzD;AACA,QAAM,WAAmB,qCAAqB,MAAM,GAAG;AACvD,QAAM,EAAE,SAAS,IAAI;AACrB,MAAI,MAAM,kBAAkB,QAAQ,OAAO,aAAa,UAAU;AAChE,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,YAAY,UAAU,QAAQ;AAC5C,MAAI,UAAU,MAAM,kBAAkB,CAAC,GAAG,SAAS,KAAK,GAAG;AACzD,WAAO;AAAA,EACT;AACA,MAAI,MAAM,eAAe,MAAM;AAC7B,UAAM,QAAQ,YAAY,UAAU,OAAO;AAC3C,QAAI,SAAS,eAAe,IAAI,IAAI,IAAI,KAAK,EAAE,QAAQ,GAAG;AACxD,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/connect/account-origin.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Which Vana Account origin serves the connect sheet.
+ *
+ * @remarks
+ * The sheet origin decides who the person signs in to and who receives the
+ * partner's request capability, so it must never come from a pattern the
+ * page URL can satisfy. {@link resolveVanaAccountOrigin} returns the
+ * environment's Vana Account origin and accepts an override only when the
+ * caller switched overrides on and the override is an exact origin from an
+ * explicit allowlist. There is deliberately no pattern or wildcard option.
+ *
+ * Zero-dependency and browser-safe, like the protocol it builds on.
+ *
+ * @category Connect
+ * @module connect/account-origin
+ */
+import { type VanaConnectEnv } from "./protocol.js";
+/** Input for {@link resolveVanaAccountOrigin}. */
+export interface ResolveVanaAccountOriginInput {
+    /** The deployment environment the app talks to. Required: there is no default. */
+    env: VanaConnectEnv;
+    /**
+     * A requested Account origin, typically read from a query parameter on a
+     * preview deploy. Untrusted. Ignored unless {@link allowOverride} is true.
+     */
+    override?: string | null;
+    /**
+     * Exact `https` origins (`https://host[:port]`, no path, no trailing slash)
+     * an override may name. Build it with {@link parseOriginAllowlist}. Entries
+     * that are not exact https origins never match.
+     */
+    previewOrigins?: readonly string[];
+    /**
+     * Whether this build honours an override at all. Decide it from build-time
+     * configuration (a non-production deploy), never from the request. Keep it
+     * `false` in production.
+     */
+    allowOverride: boolean;
+    /**
+     * Also accept an exact `http` loopback origin (`localhost`, `127.0.0.1`,
+     * `[::1]`, any port) without listing it, for a locally run Vana Account.
+     * Only applies when {@link allowOverride} is true. Defaults to `false`.
+     */
+    allowLocal?: boolean;
+}
+/**
+ * Parse a comma-separated allowlist of exact `https` origins.
+ *
+ * @remarks
+ * Whitespace around entries is trimmed. An entry that is not an exact
+ * `https://host[:port]` origin (a path, a trailing slash, `http:`, a
+ * wildcard such as `https://*.vercel.app`) is dropped, so a typo narrows
+ * the list instead of widening it.
+ *
+ * @example
+ * ```typescript
+ * parseOriginAllowlist(process.env.VANA_ACCOUNT_PREVIEW_ORIGINS);
+ * // ["https://account-git-my-branch.vercel.app"]
+ * ```
+ *
+ * @param csv - The raw list, for example an environment variable.
+ * @returns The exact https origins, deduplicated, in order.
+ */
+export declare function parseOriginAllowlist(csv: string | null | undefined): string[];
+/**
+ * Resolve the Vana Account origin that serves the connect sheet.
+ *
+ * @remarks
+ * Returns `VANA_ACCOUNT_ORIGINS[env]` unless `allowOverride` is true and
+ * `override` is exactly one of `previewOrigins` (an `https` origin), or,
+ * with `allowLocal`, exactly an `http` loopback origin. Anything else (a
+ * path, a different scheme, a near-miss host, a lookalike) falls back to the
+ * environment's origin. Matching is exact string equality: no patterns, no
+ * suffixes, no normalization that could widen a match.
+ *
+ * @example
+ * ```typescript
+ * const accountOrigin = resolveVanaAccountOrigin({
+ *   env: "dev",
+ *   override: new URLSearchParams(location.search).get("vana_account"),
+ *   previewOrigins: parseOriginAllowlist(
+ *     process.env.NEXT_PUBLIC_VANA_ACCOUNT_PREVIEW_ORIGINS,
+ *   ),
+ *   allowOverride: process.env.NEXT_PUBLIC_DEPLOY_ENV === "preview",
+ * });
+ * ```
+ *
+ * @param input - Environment, untrusted override, allowlist and switches.
+ * @returns A bare Vana Account origin.
+ * @throws TypeError when `env` is not `"production"` or `"dev"`.
+ */
+export declare function resolveVanaAccountOrigin(input: ResolveVanaAccountOriginInput): string;

package/dist/connect/account-origin.js

@@ -0,0 +1,47 @@
+import { VANA_ACCOUNT_ORIGINS } from "./protocol.js";
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+const HOSTNAME = /^(?:\[[0-9a-f:.]+\]|[a-z0-9-]+(?:\.[a-z0-9-]+)*)$/;
+function exactOrigin(value, protocol) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  return url.protocol === protocol && url.origin === value && HOSTNAME.test(url.hostname) ? value : null;
+}
+function parseOriginAllowlist(csv) {
+  if (!csv) return [];
+  const origins = [];
+  for (const entry of csv.split(",")) {
+    const origin = exactOrigin(entry.trim(), "https:");
+    if (origin && !origins.includes(origin)) origins.push(origin);
+  }
+  return origins;
+}
+function resolveVanaAccountOrigin(input) {
+  if (input.env !== "production" && input.env !== "dev") {
+    throw new TypeError('env must be "production" or "dev"');
+  }
+  const fallback = VANA_ACCOUNT_ORIGINS[input.env];
+  const { override } = input;
+  if (input.allowOverride !== true || typeof override !== "string") {
+    return fallback;
+  }
+  const https = exactOrigin(override, "https:");
+  if (https && (input.previewOrigins ?? []).includes(https)) {
+    return https;
+  }
+  if (input.allowLocal === true) {
+    const local = exactOrigin(override, "http:");
+    if (local && LOOPBACK_HOSTS.has(new URL(local).hostname)) {
+      return local;
+    }
+  }
+  return fallback;
+}
+export {
+  parseOriginAllowlist,
+  resolveVanaAccountOrigin
+};
+//# sourceMappingURL=account-origin.js.map

package/dist/connect/account-origin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/connect/account-origin.ts"],"sourcesContent":["/**\n * Which Vana Account origin serves the connect sheet.\n *\n * @remarks\n * The sheet origin decides who the person signs in to and who receives the\n * partner's request capability, so it must never come from a pattern the\n * page URL can satisfy. {@link resolveVanaAccountOrigin} returns the\n * environment's Vana Account origin and accepts an override only when the\n * caller switched overrides on and the override is an exact origin from an\n * explicit allowlist. There is deliberately no pattern or wildcard option.\n *\n * Zero-dependency and browser-safe, like the protocol it builds on.\n *\n * @category Connect\n * @module connect/account-origin\n */\n\nimport { VANA_ACCOUNT_ORIGINS, type VanaConnectEnv } from \"./protocol\";\n\n/** Input for {@link resolveVanaAccountOrigin}. */\nexport interface ResolveVanaAccountOriginInput {\n  /** The deployment environment the app talks to. Required: there is no default. */\n  env: VanaConnectEnv;\n  /**\n   * A requested Account origin, typically read from a query parameter on a\n   * preview deploy. Untrusted. Ignored unless {@link allowOverride} is true.\n   */\n  override?: string | null;\n  /**\n   * Exact `https` origins (`https://host[:port]`, no path, no trailing slash)\n   * an override may name. Build it with {@link parseOriginAllowlist}. Entries\n   * that are not exact https origins never match.\n   */\n  previewOrigins?: readonly string[];\n  /**\n   * Whether this build honours an override at all. Decide it from build-time\n   * configuration (a non-production deploy), never from the request. Keep it\n   * `false` in production.\n   */\n  allowOverride: boolean;\n  /**\n   * Also accept an exact `http` loopback origin (`localhost`, `127.0.0.1`,\n   * `[::1]`, any port) without listing it, for a locally run Vana Account.\n   * Only applies when {@link allowOverride} is true. Defaults to `false`.\n   */\n  allowLocal?: boolean;\n}\n\nconst LOOPBACK_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"[::1]\"]);\n/** DNS labels (punycode included) or a bracketed IPv6 literal; no wildcards. */\nconst HOSTNAME = /^(?:\\[[0-9a-f:.]+\\]|[a-z0-9-]+(?:\\.[a-z0-9-]+)*)$/;\n\n/** `value` itself when it is a bare origin with `protocol`, else `null`. */\nfunction exactOrigin(\n  value: string,\n  protocol: \"https:\" | \"http:\",\n): string | null {\n  let url: URL;\n  try {\n    url = new URL(value);\n  } catch {\n    return null;\n  }\n  // `url.origin === value` rejects paths, queries, fragments, credentials,\n  // trailing slashes and any spelling the URL parser would rewrite.\n  return url.protocol === protocol &&\n    url.origin === value &&\n    HOSTNAME.test(url.hostname)\n    ? value\n    : null;\n}\n\n/**\n * Parse a comma-separated allowlist of exact `https` origins.\n *\n * @remarks\n * Whitespace around entries is trimmed. An entry that is not an exact\n * `https://host[:port]` origin (a path, a trailing slash, `http:`, a\n * wildcard such as `https://*.vercel.app`) is dropped, so a typo narrows\n * the list instead of widening it.\n *\n * @example\n * ```typescript\n * parseOriginAllowlist(process.env.VANA_ACCOUNT_PREVIEW_ORIGINS);\n * // [\"https://account-git-my-branch.vercel.app\"]\n * ```\n *\n * @param csv - The raw list, for example an environment variable.\n * @returns The exact https origins, deduplicated, in order.\n */\nexport function parseOriginAllowlist(csv: string | null | undefined): string[] {\n  if (!csv) return [];\n  const origins: string[] = [];\n  for (const entry of csv.split(\",\")) {\n    const origin = exactOrigin(entry.trim(), \"https:\");\n    if (origin && !origins.includes(origin)) origins.push(origin);\n  }\n  return origins;\n}\n\n/**\n * Resolve the Vana Account origin that serves the connect sheet.\n *\n * @remarks\n * Returns `VANA_ACCOUNT_ORIGINS[env]` unless `allowOverride` is true and\n * `override` is exactly one of `previewOrigins` (an `https` origin), or,\n * with `allowLocal`, exactly an `http` loopback origin. Anything else (a\n * path, a different scheme, a near-miss host, a lookalike) falls back to the\n * environment's origin. Matching is exact string equality: no patterns, no\n * suffixes, no normalization that could widen a match.\n *\n * @example\n * ```typescript\n * const accountOrigin = resolveVanaAccountOrigin({\n *   env: \"dev\",\n *   override: new URLSearchParams(location.search).get(\"vana_account\"),\n *   previewOrigins: parseOriginAllowlist(\n *     process.env.NEXT_PUBLIC_VANA_ACCOUNT_PREVIEW_ORIGINS,\n *   ),\n *   allowOverride: process.env.NEXT_PUBLIC_DEPLOY_ENV === \"preview\",\n * });\n * ```\n *\n * @param input - Environment, untrusted override, allowlist and switches.\n * @returns A bare Vana Account origin.\n * @throws TypeError when `env` is not `\"production\"` or `\"dev\"`.\n */\nexport function resolveVanaAccountOrigin(\n  input: ResolveVanaAccountOriginInput,\n): string {\n  if (input.env !== \"production\" && input.env !== \"dev\") {\n    throw new TypeError('env must be \"production\" or \"dev\"');\n  }\n  const fallback: string = VANA_ACCOUNT_ORIGINS[input.env];\n  const { override } = input;\n  if (input.allowOverride !== true || typeof override !== \"string\") {\n    return fallback;\n  }\n  const https = exactOrigin(override, \"https:\");\n  if (https && (input.previewOrigins ?? []).includes(https)) {\n    return https;\n  }\n  if (input.allowLocal === true) {\n    const local = exactOrigin(override, \"http:\");\n    if (local && LOOPBACK_HOSTS.has(new URL(local).hostname)) {\n      return local;\n    }\n  }\n  return fallback;\n}\n"],"mappings":"AAiBA,SAAS,4BAAiD;AA+B1D,MAAM,iBAAiB,oBAAI,IAAI,CAAC,aAAa,aAAa,OAAO,CAAC;AAElE,MAAM,WAAW;AAGjB,SAAS,YACP,OACA,UACe;AACf,MAAI;AACJ,MAAI;AACF,UAAM,IAAI,IAAI,KAAK;AAAA,EACrB,QAAQ;AACN,WAAO;AAAA,EACT;AAGA,SAAO,IAAI,aAAa,YACtB,IAAI,WAAW,SACf,SAAS,KAAK,IAAI,QAAQ,IACxB,QACA;AACN;AAoBO,SAAS,qBAAqB,KAA0C;AAC7E,MAAI,CAAC,IAAK,QAAO,CAAC;AAClB,QAAM,UAAoB,CAAC;AAC3B,aAAW,SAAS,IAAI,MAAM,GAAG,GAAG;AAClC,UAAM,SAAS,YAAY,MAAM,KAAK,GAAG,QAAQ;AACjD,QAAI,UAAU,CAAC,QAAQ,SAAS,MAAM,EAAG,SAAQ,KAAK,MAAM;AAAA,EAC9D;AACA,SAAO;AACT;AA6BO,SAAS,yBACd,OACQ;AACR,MAAI,MAAM,QAAQ,gBAAgB,MAAM,QAAQ,OAAO;AACrD,UAAM,IAAI,UAAU,mCAAmC;AAAA,EACzD;AACA,QAAM,WAAmB,qBAAqB,MAAM,GAAG;AACvD,QAAM,EAAE,SAAS,IAAI;AACrB,MAAI,MAAM,kBAAkB,QAAQ,OAAO,aAAa,UAAU;AAChE,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,YAAY,UAAU,QAAQ;AAC5C,MAAI,UAAU,MAAM,kBAAkB,CAAC,GAAG,SAAS,KAAK,GAAG;AACzD,WAAO;AAAA,EACT;AACA,MAAI,MAAM,eAAe,MAAM;AAC7B,UAAM,QAAQ,YAAY,UAAU,OAAO;AAC3C,QAAI,SAAS,eAAe,IAAI,IAAI,IAAI,KAAK,EAAE,QAAQ,GAAG;AACxD,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/connect/account-origin.test.d.ts

@@ -0,0 +1 @@
+export {};