@nuxtjp/local-runtime 0.0.0-stage → 0.1.0

package/dist/runtime/client/client.js

@@ -0,0 +1,117 @@
+import {
+  isLocalRuntimeManifest,
+  isSessionGrant,
+  isViewEnvelope
+} from "../shared/guards.js";
+import { requireLoopbackEndpoint, runtimeUrl } from "./endpoint.js";
+import { localRequest } from "./request.js";
+import { localJson } from "./transport.js";
+export class LocalRuntimeClient {
+  endpoint;
+  origin;
+  fetcher;
+  maximumResponseBytes;
+  timeoutMilliseconds;
+  grant = null;
+  runtimeManifest = null;
+  constructor(options) {
+    this.endpoint = requireLoopbackEndpoint(options.endpoint);
+    this.origin = new URL(options.origin).origin;
+    this.fetcher = options.fetcher || fetch;
+    this.maximumResponseBytes = options.maximumResponseBytes || 256 * 1024;
+    this.timeoutMilliseconds = options.timeoutMilliseconds || 5e3;
+    if (!Number.isSafeInteger(this.maximumResponseBytes) || this.maximumResponseBytes <= 0 || this.maximumResponseBytes > 8 * 1024 * 1024) {
+      throw new Error("maximum response bytes are outside the local boundary");
+    }
+    if (!Number.isSafeInteger(this.timeoutMilliseconds) || this.timeoutMilliseconds < 50 || this.timeoutMilliseconds > 3e4) {
+      throw new Error("timeout is outside the local boundary");
+    }
+  }
+  async manifest() {
+    const value = await localJson(
+      this.fetcher,
+      runtimeUrl(this.endpoint, "/v1/manifest"),
+      localRequest("GET"),
+      this.maximumResponseBytes,
+      this.timeoutMilliseconds
+    );
+    if (!isLocalRuntimeManifest(value) || !value.security.allowed_origins.includes(this.origin)) {
+      throw new Error("invalid runtime manifest");
+    }
+    this.runtimeManifest = value;
+    return value;
+  }
+  async connect(capabilities) {
+    if (!this.runtimeManifest) throw new Error("runtime manifest is not loaded");
+    if (capabilities.length > 64 || capabilities.some((capability) => !capability || capability.length > 128)) {
+      throw new Error("requested capabilities exceed the local boundary");
+    }
+    const available = new Set(
+      this.runtimeManifest.capabilities.map((capability) => capability.id)
+    );
+    if (capabilities.some((capability) => !available.has(capability))) {
+      throw new Error("requested capability is not declared");
+    }
+    const request = {
+      schema: "nuxtjp://local-runtime/session-request/v1",
+      origin: this.origin,
+      audience: this.origin,
+      client_nonce: crypto.randomUUID(),
+      requested_capabilities: [...new Set(capabilities)]
+    };
+    const value = await localJson(
+      this.fetcher,
+      runtimeUrl(this.endpoint, "/v1/session"),
+      localRequest("POST", { body: request }),
+      this.maximumResponseBytes,
+      this.timeoutMilliseconds
+    );
+    const expected = [...new Set(capabilities)].sort();
+    const observed = isSessionGrant(value) ? [...value.granted_capabilities].sort() : [];
+    const now = Math.floor(Date.now() / 1e3);
+    const limits = this.runtimeManifest.security.limits;
+    if (!isSessionGrant(value) || value.audience !== this.origin || value.expires_at_unix_seconds <= now || value.expires_at_unix_seconds > now + limits.session_ttl_seconds + 5 || JSON.stringify(observed) !== JSON.stringify(expected) || value.budget.max_messages > limits.max_messages_per_minute || value.budget.max_bytes > limits.max_bytes_per_minute) {
+      throw new Error("invalid runtime session grant");
+    }
+    this.grant = value;
+    return value;
+  }
+  async view(capabilityId, viewId) {
+    if (!this.grant || !this.runtimeManifest) {
+      throw new Error("local runtime session is not connected");
+    }
+    if (!this.grant.granted_capabilities.includes(capabilityId)) {
+      throw new Error("capability was not granted");
+    }
+    const request = {
+      schema: "nuxtjp://local-runtime/view-request/v1",
+      capability_id: capabilityId,
+      view_id: viewId,
+      request_nonce: crypto.randomUUID()
+    };
+    const value = await localJson(
+      this.fetcher,
+      runtimeUrl(this.endpoint, "/v1/view"),
+      localRequest("POST", { body: request, token: this.grant.token }),
+      this.maximumResponseBytes,
+      this.timeoutMilliseconds
+    );
+    const capability = this.runtimeManifest.capabilities.find((item) => item.id === capabilityId);
+    if (!capability || !isViewEnvelope(value, capability.payload_schema) || value.capability_id !== capabilityId || value.view_id !== viewId) {
+      throw new Error("invalid runtime view");
+    }
+    return value;
+  }
+  async disconnect() {
+    const token = this.grant?.token;
+    this.grant = null;
+    if (!token) return;
+    await localJson(
+      this.fetcher,
+      runtimeUrl(this.endpoint, "/v1/session"),
+      localRequest("DELETE", { token }),
+      this.maximumResponseBytes,
+      this.timeoutMilliseconds
+    );
+  }
+}

package/dist/runtime/client/endpoint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * DNS names are rejected so local routing cannot change after validation.
+ */
+export declare function requireLoopbackEndpoint(endpoint: string): URL;
+export declare function runtimeUrl(endpoint: URL, path: string): URL;

package/dist/runtime/client/endpoint.js

@@ -0,0 +1,14 @@
+const numericLoopbackHosts = /* @__PURE__ */ new Set(["127.0.0.1", "[::1]"]);
+export function requireLoopbackEndpoint(endpoint) {
+  const url = new URL(endpoint);
+  if (!["http:", "https:"].includes(url.protocol) || !numericLoopbackHosts.has(url.hostname) || url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") {
+    throw new Error("local runtime endpoint must be a bare numeric loopback origin");
+  }
+  return url;
+}
+export function runtimeUrl(endpoint, path) {
+  if (!path.startsWith("/") || path.includes("..")) {
+    throw new Error("local runtime path is invalid");
+  }
+  return new URL(path, endpoint);
+}

package/dist/runtime/client/index.d.ts

@@ -0,0 +1,6 @@
+export { LocalRuntimeClient } from './client.js';
+export type { LocalRuntimeClientOptions } from './client.js';
+export { requireLoopbackEndpoint } from './endpoint.js';
+export { localJson } from './transport.js';
+export { bandAllowsTarget, isBrowserVisibleBand } from '../shared/security.js';
+export type * from '../shared/types';

package/dist/runtime/client/index.js

@@ -0,0 +1,4 @@
+export { LocalRuntimeClient } from "./client.js";
+export { requireLoopbackEndpoint } from "./endpoint.js";
+export { localJson } from "./transport.js";
+export { bandAllowsTarget, isBrowserVisibleBand } from "../shared/security.js";

package/dist/runtime/client/request.d.ts

@@ -0,0 +1,5 @@
+export interface LocalRequestOptions {
+    body?: unknown;
+    token?: string;
+}
+export declare function localRequest(method: 'GET' | 'POST' | 'DELETE', options?: LocalRequestOptions): RequestInit;

package/dist/runtime/client/request.js

@@ -0,0 +1,22 @@
+export function localRequest(method, options = {}) {
+  const headers = {
+    accept: "application/json",
+    "x-nuxtjp-local-runtime": "1"
+  };
+  let body;
+  if (options.body !== void 0) {
+    body = JSON.stringify(options.body);
+    headers["content-type"] = "application/json";
+  }
+  if (options.token) headers.authorization = `Bearer ${options.token}`;
+  return {
+    method,
+    headers,
+    ...body === void 0 ? {} : { body },
+    cache: "no-store",
+    credentials: "omit",
+    redirect: "error",
+    referrerPolicy: "no-referrer",
+    mode: "cors"
+  };
+}

package/dist/runtime/client/response.d.ts

@@ -0,0 +1 @@
+export declare function boundedJson(response: Response, maximumBytes: number): Promise<unknown>;

package/dist/runtime/client/response.js

@@ -0,0 +1,36 @@
+export async function boundedJson(response, maximumBytes) {
+  if (!response.ok) {
+    throw new Error(`local runtime returned HTTP ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type")?.split(";")[0]?.trim();
+  if (contentType !== "application/json") {
+    throw new Error("local runtime response must be application/json");
+  }
+  const declaredLength = response.headers.get("content-length");
+  const contentLength = declaredLength === null ? null : Number(declaredLength);
+  if (contentLength !== null && (!Number.isSafeInteger(contentLength) || contentLength < 0 || contentLength > maximumBytes)) {
+    throw new Error("local runtime response exceeds the byte limit");
+  }
+  if (!response.body) throw new Error("local runtime response body is missing");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  while (true) {
+    const result = await reader.read();
+    if (result.done) break;
+    byteLength += result.value.byteLength;
+    if (byteLength > maximumBytes) {
+      await reader.cancel();
+      throw new Error("local runtime response exceeds the byte limit");
+    }
+    chunks.push(result.value);
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  return JSON.parse(text);
+}

package/dist/runtime/client/transport.d.ts

@@ -0,0 +1 @@
+export declare function localJson(fetcher: typeof fetch, url: URL, init: RequestInit, maximumBytes: number, timeoutMilliseconds: number): Promise<unknown>;

package/dist/runtime/client/transport.js

@@ -0,0 +1,11 @@
+import { boundedJson } from "./response.js";
+export async function localJson(fetcher, url, init, maximumBytes, timeoutMilliseconds) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMilliseconds);
+  try {
+    const response = await fetcher(url, { ...init, signal: controller.signal });
+    return await boundedJson(response, maximumBytes);
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/dist/runtime/shared/guards/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { LocalRuntimeManifest } from '../types.js';
+export declare function isLocalRuntimeManifest(value: unknown): value is LocalRuntimeManifest;

package/dist/runtime/shared/guards/manifest.js

@@ -0,0 +1,71 @@
+import {
+  hasExactKeys,
+  isRecord,
+  isSafeCount,
+  isStringArray,
+  isText
+} from "./primitives.js";
+import { isPayloadSchema } from "./payload.js";
+const manifestKeys = [
+  "capabilities",
+  "engine",
+  "external_actions",
+  "mode",
+  "protocol_version",
+  "runtime_id",
+  "schema",
+  "security"
+];
+function isLimits(value) {
+  if (!isRecord(value) || !hasExactKeys(value, [
+    "max_bytes_per_minute",
+    "max_messages_per_minute",
+    "max_request_bytes",
+    "max_response_bytes",
+    "session_ttl_seconds"
+  ])) return false;
+  return isSafeCount(value.max_request_bytes) && value.max_request_bytes > 0 && value.max_request_bytes <= 1024 * 1024 && isSafeCount(value.max_response_bytes) && value.max_response_bytes > 0 && value.max_response_bytes <= 8 * 1024 * 1024 && isSafeCount(value.max_messages_per_minute) && value.max_messages_per_minute > 0 && value.max_messages_per_minute <= 600 && isSafeCount(value.max_bytes_per_minute) && value.max_bytes_per_minute > 0 && value.max_bytes_per_minute <= 64 * 1024 * 1024 && isSafeCount(value.session_ttl_seconds) && value.session_ttl_seconds > 0 && value.session_ttl_seconds <= 3600;
+}
+function isCapability(value) {
+  if (!isRecord(value) || !hasExactKeys(value, [
+    "description",
+    "id",
+    "output_band",
+    "payload_schema",
+    "service_id"
+  ])) return false;
+  return isText(value.id) && value.id.length <= 128 && isText(value.service_id) && value.service_id.length <= 128 && isText(value.description) && value.description.length <= 4096 && ["session", "public"].includes(String(value.output_band)) && isPayloadSchema(value.payload_schema);
+}
+function isAllowedOrigins(value) {
+  if (!isStringArray(value) || value.length === 0 || value.length > 16) {
+    return false;
+  }
+  if (new Set(value).size !== value.length) return false;
+  return value.every((origin) => {
+    try {
+      const url = new URL(origin);
+      return ["http:", "https:"].includes(url.protocol) && url.origin === origin && !url.username && !url.password;
+    } catch {
+      return false;
+    }
+  });
+}
+export function isLocalRuntimeManifest(value) {
+  if (!isRecord(value) || !hasExactKeys(value, manifestKeys)) return false;
+  const { engine, security } = value;
+  if (!isRecord(engine) || !hasExactKeys(engine, [
+    "arbitrary_filesystem",
+    "arbitrary_network",
+    "isolation",
+    "kind",
+    "status"
+  ])) return false;
+  if (!isRecord(security) || !hasExactKeys(security, [
+    "allowed_origins",
+    "default_band",
+    "external_egress",
+    "limits"
+  ])) return false;
+  const capabilitiesValid = Array.isArray(value.capabilities) && value.capabilities.length <= 64 && value.capabilities.every(isCapability) && new Set(value.capabilities.map((item) => String(item.id))).size === value.capabilities.length;
+  return value.schema === "nuxtjp://local-runtime/manifest/v1" && isText(value.runtime_id) && value.protocol_version === "1" && ["local-simulation", "local-production"].includes(String(value.mode)) && value.external_actions === false && engine.kind === "rust-v8" && ["disabled", "simulated", "ready"].includes(String(engine.status)) && (engine.status === "ready" && engine.isolation === "process" || engine.status !== "ready" && engine.isolation === "in-process-simulation") && engine.arbitrary_network === false && engine.arbitrary_filesystem === false && security.default_band === "sealed" && security.external_egress === "deny" && isAllowedOrigins(security.allowed_origins) && isLimits(security.limits) && capabilitiesValid;
+}

package/dist/runtime/shared/guards/payload.d.ts

@@ -0,0 +1,3 @@
+import type { PayloadScalar, RuntimePayloadSchema } from '../types.js';
+export declare function isPayloadSchema(value: unknown): value is RuntimePayloadSchema;
+export declare function matchesPayloadSchema(value: unknown, schema: RuntimePayloadSchema): value is Record<string, PayloadScalar>;

package/dist/runtime/shared/guards/payload.js

@@ -0,0 +1,29 @@
+import {
+  hasExactKeys,
+  isRecord,
+  isSafeCount,
+  isText
+} from "./primitives.js";
+const fieldName = /^[a-z][a-z0-9_]{0,63}$/;
+function isPayloadField(value) {
+  return isRecord(value) && hasExactKeys(value, ["kind", "name"]) && isText(value.name) && fieldName.test(value.name) && ["text", "count", "boolean"].includes(String(value.kind));
+}
+export function isPayloadSchema(value) {
+  if (!isRecord(value) || !hasExactKeys(value, ["fields", "id"])) return false;
+  if (!isText(value.id) || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value.id) || !Array.isArray(value.fields)) return false;
+  if (value.fields.length === 0 || value.fields.length > 32) return false;
+  if (!value.fields.every(isPayloadField)) return false;
+  return new Set(value.fields.map((field) => field.name)).size === value.fields.length;
+}
+function matchesKind(value, kind) {
+  if (kind === "text") {
+    return isText(value) && new TextEncoder().encode(value).byteLength <= 4096;
+  }
+  if (kind === "count") return isSafeCount(value);
+  return kind === "boolean" && typeof value === "boolean";
+}
+export function matchesPayloadSchema(value, schema) {
+  if (!isPayloadSchema(schema) || !isRecord(value)) return false;
+  if (!hasExactKeys(value, schema.fields.map((field) => field.name))) return false;
+  return schema.fields.every((field) => matchesKind(value[field.name], field.kind));
+}

package/dist/runtime/shared/guards/primitives.d.ts

@@ -0,0 +1,5 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function hasExactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean;
+export declare function isText(value: unknown): value is string;
+export declare function isStringArray(value: unknown): value is string[];
+export declare function isSafeCount(value: unknown): value is number;

package/dist/runtime/shared/guards/primitives.js

@@ -0,0 +1,16 @@
+export function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function hasExactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  return actual.length === keys.length && actual.every((key, index) => key === [...keys].sort()[index]);
+}
+export function isText(value) {
+  return typeof value === "string" && value.length > 0;
+}
+export function isStringArray(value) {
+  return Array.isArray(value) && value.every(isText);
+}
+export function isSafeCount(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}

package/dist/runtime/shared/guards/session.d.ts

@@ -0,0 +1,2 @@
+import type { SessionGrant } from '../types.js';
+export declare function isSessionGrant(value: unknown): value is SessionGrant;

package/dist/runtime/shared/guards/session.js

@@ -0,0 +1,27 @@
+import {
+  hasExactKeys,
+  isRecord,
+  isSafeCount,
+  isStringArray,
+  isText
+} from "./primitives.js";
+export function isSessionGrant(value) {
+  if (!isRecord(value) || !hasExactKeys(value, [
+    "audience",
+    "budget",
+    "classification_ceiling",
+    "expires_at_unix_seconds",
+    "external_actions",
+    "granted_capabilities",
+    "schema",
+    "session_id",
+    "subject_id",
+    "token"
+  ])) return false;
+  const budget = value.budget;
+  if (!isRecord(budget) || !hasExactKeys(budget, [
+    "max_bytes",
+    "max_messages"
+  ])) return false;
+  return value.schema === "nuxtjp://local-runtime/session-grant/v1" && isText(value.session_id) && isText(value.token) && isText(value.subject_id) && isText(value.audience) && isSafeCount(value.expires_at_unix_seconds) && isStringArray(value.granted_capabilities) && value.granted_capabilities.length <= 64 && new Set(value.granted_capabilities).size === value.granted_capabilities.length && value.classification_ceiling === "session" && isSafeCount(budget.max_messages) && budget.max_messages > 0 && isSafeCount(budget.max_bytes) && budget.max_bytes > 0 && value.external_actions === false;
+}

package/dist/runtime/shared/guards/view.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePayloadSchema, ViewEnvelope } from '../types.js';
+export declare function isViewEnvelope(value: unknown, payloadSchema: RuntimePayloadSchema): value is ViewEnvelope;

package/dist/runtime/shared/guards/view.js

@@ -0,0 +1,22 @@
+import {
+  hasExactKeys,
+  isRecord,
+  isSafeCount,
+  isText
+} from "./primitives.js";
+import { isBrowserVisibleBand } from "../security.js";
+import { matchesPayloadSchema } from "./payload.js";
+export function isViewEnvelope(value, payloadSchema) {
+  if (!isRecord(value) || !hasExactKeys(value, [
+    "band",
+    "capability_id",
+    "expires_at_unix_seconds",
+    "external_actions",
+    "generated_at_unix_seconds",
+    "payload",
+    "payload_schema_id",
+    "schema",
+    "view_id"
+  ])) return false;
+  return value.schema === "nuxtjp://local-runtime/view/v1" && isText(value.capability_id) && isText(value.view_id) && value.payload_schema_id === payloadSchema.id && isBrowserVisibleBand(value.band) && isSafeCount(value.generated_at_unix_seconds) && isSafeCount(value.expires_at_unix_seconds) && value.expires_at_unix_seconds >= value.generated_at_unix_seconds && value.external_actions === false && matchesPayloadSchema(value.payload, payloadSchema);
+}

package/dist/runtime/shared/guards.d.ts

@@ -0,0 +1,4 @@
+export { isLocalRuntimeManifest } from './guards/manifest.js';
+export { isSessionGrant } from './guards/session.js';
+export { isViewEnvelope } from './guards/view.js';
+export { isPayloadSchema, matchesPayloadSchema } from './guards/payload.js';

package/dist/runtime/shared/guards.js

@@ -0,0 +1,4 @@
+export { isLocalRuntimeManifest } from "./guards/manifest.js";
+export { isSessionGrant } from "./guards/session.js";
+export { isViewEnvelope } from "./guards/view.js";
+export { isPayloadSchema, matchesPayloadSchema } from "./guards/payload.js";

package/dist/runtime/shared/nuxt-imports.d.ts

@@ -0,0 +1,9 @@
+declare module '#imports' {
+  export function useRuntimeConfig(): {
+    public: {
+      nuxtJpLocalRuntime: {
+        endpoint: string
+      }
+    }
+  }
+}

package/dist/runtime/shared/security.d.ts

@@ -0,0 +1,7 @@
+import type { BoundaryTarget, InformationBand } from './types.js';
+/**
+ * Information may cross only the boundary named by its reviewed band.
+ * Transforming or declassifying a record is a separate host responsibility.
+ */
+export declare function bandAllowsTarget(band: InformationBand, target: BoundaryTarget): boolean;
+export declare function isBrowserVisibleBand(band: InformationBand): band is 'session' | 'public';

package/dist/runtime/shared/security.js

@@ -0,0 +1,13 @@
+const boundaryByBand = {
+  sealed: "none",
+  local: "local-mesh",
+  session: "loopback-browser",
+  control: "external-control",
+  public: "public-network"
+};
+export function bandAllowsTarget(band, target) {
+  return boundaryByBand[band] === target;
+}
+export function isBrowserVisibleBand(band) {
+  return band === "session" || band === "public";
+}

package/dist/runtime/shared/types.d.ts

@@ -0,0 +1,95 @@
+export type InformationBand = 'sealed' | 'local' | 'session' | 'control' | 'public';
+export type BoundaryTarget = 'none' | 'local-mesh' | 'loopback-browser' | 'external-control' | 'public-network';
+export interface RuntimeEngine {
+    kind: 'rust-v8';
+    status: 'disabled' | 'simulated' | 'ready';
+    isolation: 'in-process-simulation' | 'process';
+    arbitrary_network: false;
+    arbitrary_filesystem: false;
+}
+export interface RuntimeLimits {
+    max_request_bytes: number;
+    max_response_bytes: number;
+    max_messages_per_minute: number;
+    max_bytes_per_minute: number;
+    session_ttl_seconds: number;
+}
+export interface RuntimeSecurity {
+    default_band: 'sealed';
+    external_egress: 'deny';
+    allowed_origins: string[];
+    limits: RuntimeLimits;
+}
+export type PayloadValueKind = 'text' | 'count' | 'boolean';
+export type PayloadScalar = string | number | boolean;
+export interface RuntimePayloadField {
+    name: string;
+    kind: PayloadValueKind;
+}
+export interface RuntimePayloadSchema {
+    id: string;
+    fields: RuntimePayloadField[];
+}
+export interface RuntimeCapability {
+    id: string;
+    service_id: string;
+    description: string;
+    output_band: 'session' | 'public';
+    payload_schema: RuntimePayloadSchema;
+}
+export interface LocalRuntimeManifest {
+    schema: 'nuxtjp://local-runtime/manifest/v1';
+    runtime_id: string;
+    protocol_version: '1';
+    mode: 'local-simulation' | 'local-production';
+    external_actions: false;
+    engine: RuntimeEngine;
+    security: RuntimeSecurity;
+    capabilities: RuntimeCapability[];
+}
+export interface SessionRequest {
+    schema: 'nuxtjp://local-runtime/session-request/v1';
+    origin: string;
+    audience: string;
+    client_nonce: string;
+    requested_capabilities: string[];
+}
+export interface SessionBudget {
+    max_messages: number;
+    max_bytes: number;
+}
+export interface SessionGrant {
+    schema: 'nuxtjp://local-runtime/session-grant/v1';
+    session_id: string;
+    token: string;
+    subject_id: string;
+    audience: string;
+    expires_at_unix_seconds: number;
+    granted_capabilities: string[];
+    classification_ceiling: 'session';
+    budget: SessionBudget;
+    external_actions: false;
+}
+export interface ViewRequest {
+    schema: 'nuxtjp://local-runtime/view-request/v1';
+    capability_id: string;
+    view_id: string;
+    request_nonce: string;
+}
+export interface ViewEnvelope {
+    schema: 'nuxtjp://local-runtime/view/v1';
+    capability_id: string;
+    view_id: string;
+    payload_schema_id: string;
+    band: 'session' | 'public';
+    generated_at_unix_seconds: number;
+    expires_at_unix_seconds: number;
+    external_actions: false;
+    payload: Record<string, PayloadScalar>;
+}
+export type ConnectionPhase = 'idle' | 'connecting' | 'connected' | 'denied' | 'unavailable';
+export interface LocalRuntimeState {
+    phase: ConnectionPhase;
+    manifest: LocalRuntimeManifest | null;
+    error: string | null;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'