@exponential_app/engine 0.0.0-stage → 0.1.0

package/dist/chunks/index-t89cvabm.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../packages/eengine/src/runner.ts"],
+  "sourcesContent": [
+    "// E6 (#VAPP-266 … #VAPP-269): the runner, the prebuilt shell an exported app\n// runs in on macOS, Windows, Linux, Android, iOS and the web. It has no chrome\n// of its own: its navigation, its Permissions entry, a package that cannot\n// load and the failed-action toast are genUI surfaces made of existing\n// components, built here once (the Rust twin `eengine::runner` replays the\n// same cases; Swift and Kotlin reach it over `eengine-ffi`). Locked by\n// `fixtures/runner.json`.\n\nimport { navScreens, packageScreens } from \"@exponential_app/eui/host\"\n\nimport fixture from \"../fixtures/runner.json\" with { type: \"json\" }\nimport type { ManifestEntry } from \"./capabilities\"\nimport { scopeDef } from \"./capabilities\"\nimport type { SurfaceComponent } from \"./consent\"\nimport type { NetworkPolicy } from \"./providers\"\n\nexport const RUNNER_COPY = fixture.copy\nexport const RUNNER_BUNDLE = fixture.bundle\nexport const RUNNER_SHELL = fixture.shell\n\nexport type FormFactor = `wide` | `compact`\nexport type RunnerFailure = `missing` | `config` | `signature` | `invalid` | `busy`\n\n// ---------------------------------------------------------------- config\n\n/** A bundle's `runner.json`, validated. */\nexport interface RunnerConfig {\n  id: string\n  name: string\n  version: string\n  network: NetworkPolicy\n}\n\nexport interface RunnerConfigIssue {\n  key: string\n  code: string\n}\n\nconst CONFIG_KEYS = Object.keys(fixture.config.keys)\n\n/** `runner.json` → the config (absent optional keys = their default) and its issues, in key order then the extra keys sorted. */\nexport function runnerConfig(input: unknown): { config: RunnerConfig | null; issues: RunnerConfigIssue[] } {\n  if (!input || typeof input !== `object` || Array.isArray(input)) return { config: null, issues: [{ key: ``, code: `notAnObject` }] }\n  const raw = input as Record<string, unknown>\n  const issues: RunnerConfigIssue[] = []\n  const out: Record<string, unknown> = {}\n  for (const key of CONFIG_KEYS) {\n    const def = (fixture.config.keys as Record<string, { required?: boolean; pattern?: string; maxLength?: number; values?: string[]; default?: string }>)[key]!\n    const value = raw[key]\n    if (value === undefined) {\n      if (def.required) issues.push({ key, code: `missing` })\n      else out[key] = def.default\n      continue\n    }\n    const ok =\n      typeof value === `string` &&\n      (!def.pattern || new RegExp(def.pattern).test(value)) &&\n      (!def.maxLength || ([...value].length <= def.maxLength && value.trim().length > 0)) &&\n      (!def.values || def.values.includes(value))\n    if (ok) out[key] = value\n    else issues.push({ key, code: `invalid` })\n  }\n  const extra = Object.keys(raw)\n    .filter((k) => !CONFIG_KEYS.includes(k))\n    .sort()\n  for (const key of extra) issues.push({ key, code: fixture.config.forbidden.includes(key) ? `forbidden` : `unknown` })\n  return { config: issues.length ? null : (out as unknown as RunnerConfig), issues }\n}\n\n// ---------------------------------------------------------------- the shell\n\ntype Pkg = Record<string, unknown> & { name?: unknown; templates?: unknown; screens?: unknown; capabilities?: unknown }\ntype Template = Record<string, unknown> & { components?: unknown; data?: unknown }\n\nconst manifestOf = (pkg: Pkg): ManifestEntry[] => (Array.isArray(pkg.capabilities) ? (pkg.capabilities as ManifestEntry[]) : [])\n\n/** Does the package declare an `ask` scope (the shell then offers Permissions)? */\nexport function runnerHasPermissions(pkg: Pkg): boolean {\n  return manifestOf(pkg).some((m) => {\n    const def = scopeDef(m.id)\n    return !!def && !def.scope.hostOnly && def.scope.consent === `ask`\n  })\n}\n\nconst event = (name: string, context?: Record<string, unknown>) => ({ event: context ? { name, context } : { name } })\n\n/** The shell around one screen's template: its components (the template's root becomes `runner_page`) and its extra data. */\nfunction shellComponents(pkg: Pkg, screen: string, components: SurfaceComponent[], formFactor: FormFactor): { components: SurfaceComponent[]; data: Record<string, unknown> | null } {\n  const nav = navScreens(pkg)\n  const permissions = runnerHasPermissions(pkg)\n  const tabs = nav.length >= 2\n  const page = components.map((c) => (c.id === `root` ? { ...c, id: `runner_page` } : c))\n  if (!tabs && !permissions)\n    return { components: [{ id: `root`, component: `Box`, style: { display: `flex`, flexDirection: `column`, height: `100%`, overflowY: `auto` }, children: [`runner_page`] }, ...page], data: null }\n  const S = fixture.shell\n  if (formFactor === `wide`) {\n    const nav_children = [`runner_title`, ...(tabs ? [`runner_screens`] : []), ...(permissions ? [`runner_permissions`] : [])]\n    const shell: SurfaceComponent[] = [\n      { id: `root`, component: `Stack`, direction: `horizontal`, gap: `none`, align: `stretch`, style: { height: `100%` }, children: [`runner_sidebar`] },\n      { id: `runner_sidebar`, component: `Sidebar`, width: S.sidebarWidth, collapseBelow: `never`, children: [`runner_scroll`], slots: { sidebar: `runner_nav` } },\n      { id: `runner_scroll`, component: `Box`, style: { display: `flex`, flexDirection: `column`, flexGrow: 1, minHeight: 0, overflowY: `auto` }, children: [`runner_page`] },\n      { id: `runner_nav`, component: `Stack`, gap: `sm`, style: { padding: `$spacing.sm` }, children: nav_children },\n      { id: `runner_title`, component: `Heading`, text: typeof pkg.name === `string` ? pkg.name : ``, level: S.titleLevel },\n    ]\n    if (tabs)\n      shell.push(\n        { id: `runner_screens`, component: `List`, children: nav.map((_, i) => `runner_screen_${i}`) },\n        ...nav.map((s, i) => ({\n          id: `runner_screen_${i}`,\n          component: `Row`,\n          title: s.title ?? s.template,\n          ...(s.icon ? { icon: s.icon } : {}),\n          selected: s.template === screen,\n          density: `compact`,\n          pressable: true,\n          on: { press: event(`runner.navigate`, { screen: s.template }) },\n        })),\n      )\n    if (permissions)\n      shell.push({ id: `runner_permissions`, component: `Row`, title: fixture.copy.permissions, icon: S.permissionsIcon, density: `compact`, pressable: true, on: { press: event(`runner.permissions`) } })\n    return { components: [...shell, ...page], data: null }\n  }\n  const bar = [...(tabs ? [`runner_tabs_box`] : []), ...(permissions ? [`runner_permissions`] : [])]\n  const shell: SurfaceComponent[] = [\n    { id: `root`, component: `Stack`, gap: `none`, style: { height: `100%` }, children: [`runner_main`, `runner_separator`, `runner_bar`] },\n    { id: `runner_main`, component: `Box`, style: { display: `flex`, flexDirection: `column`, flexGrow: 1, minHeight: 0, overflowY: `auto` }, children: [`runner_page`] },\n    { id: `runner_separator`, component: `Separator` },\n    { id: `runner_bar`, component: `Stack`, direction: `horizontal`, gap: `sm`, align: `center`, justify: `end`, style: { padding: `$spacing.sm` }, children: bar },\n  ]\n  if (tabs)\n    shell.push(\n      { id: `runner_tabs_box`, component: `Box`, style: { display: `flex`, flexDirection: `column`, flexGrow: 1, minWidth: 0 }, children: [`runner_tabs`] },\n      {\n        id: `runner_tabs`,\n        component: `Tabs`,\n        tabs: nav.map((s) => ({ label: s.title ?? s.template, value: s.template, ...(s.icon ? { icon: s.icon } : {}) })),\n        value: { \"@path\": `/runner/screen` },\n        fill: true,\n        on: { change: event(`runner.navigate`, { screen: { \"@path\": `/runner/screen` } }) },\n      },\n    )\n  if (permissions)\n    shell.push({ id: `runner_permissions`, component: `Button`, label: fixture.copy.permissions, icon: S.permissionsIcon, size: `icon`, variant: `ghost`, on: { press: event(`runner.permissions`) } })\n  return { components: [...shell, ...page], data: tabs ? { runner: { screen } } : null }\n}\n\n/**\n * The package the runner's painter installs: every screen's template wrapped\n * in the shell for `formFactor`. A package without screens gets one, its first\n * template. The Engine keeps the ORIGINAL package (its signature, its grants);\n * only the painter sees this one.\n */\nexport function runnerPackage(pkg: Pkg, formFactor: FormFactor): Pkg {\n  const templates = pkg.templates && typeof pkg.templates === `object` ? (pkg.templates as Record<string, Template>) : {}\n  let out: Pkg = pkg\n  if (packageScreens(pkg).length === 0) {\n    const first = Object.keys(templates)[0]\n    if (!first) return pkg\n    out = { ...pkg, screens: [{ template: first, title: typeof pkg.name === `string` ? pkg.name : first }] }\n  }\n  const wrapped: Record<string, Template> = { ...templates }\n  for (const s of packageScreens(out)) {\n    const t = templates[s.template]\n    if (!t || !Array.isArray(t.components)) continue\n    const { components, data } = shellComponents(out, s.template, t.components as SurfaceComponent[], formFactor)\n    if (components === t.components) continue\n    const base = t.data && typeof t.data === `object` && !Array.isArray(t.data) ? (t.data as Record<string, unknown>) : {}\n    wrapped[s.template] = { ...t, components, ...(data ? { data: { ...base, ...data } } : {}) }\n  }\n  return { ...out, templates: wrapped }\n}\n\n// ---------------------------------------------------------------- surfaces\n\n/** What the runner paints instead of the app when its bundle cannot load. */\nexport function runnerFailure(kind: RunnerFailure): SurfaceComponent[] {\n  return [{ id: `root`, component: `EmptyState`, icon: fixture.shell.failureIcon, title: fixture.copy.failed.title, description: fixture.copy.failed[kind] }]\n}\n\n/** The failed-action toast (a refused call, a refused link): surface `toast`; a broker reason code reads as `copy.refusals`. */\nexport function runnerToast(message: string): SurfaceComponent[] {\n  const refusals = fixture.copy.refusals as Record<string, string>\n  return [{ id: `root`, component: `Toast`, title: Object.hasOwn(refusals, message) ? refusals[message]! : message, type: `error` }]\n}\n"
+  ],
+  "mappings": ";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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",
+  "debugId": "8614238A2FCD206064756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-zw0575tv.js

@@ -0,0 +1,126 @@
+import {
+  capabilityNameValid2
+} from "./index-md3hz6r2.js";
+
+// packages/eengine/src/providers.ts
+import { recordRefusal } from "@exponential_app/eui/host";
+// packages/eengine/fixtures/providers.json
+var providers_default = {
+  $comment: "VAPP-260 (Engine E0, epic VAPP-259, docs/spec/apps.md §13.1): WHAT A HOST HANDS THE ENGINE, the `HostConfig`. Each key of `providers` is `required` (the Engine refuses to start without it: `missing`) or optional (absent = its `default`); `list: true` = zero or more. There is NO telemetry and NO update provider: `forbidden` keys are refused by name (`forbidden`), so an exported runner can never grow an analytics, crash-report or over-the-air channel through its config (a new package version = a rebundle, decided 2026-11-05); any other unknown key is `unknown`. `network` is one of `networkPolicies`; `identity.kind` one of `identityKinds`. A capability is mounted under its name (capabilities.json), each name once (`duplicateCapability`); an agent provider (Agents' `AgentProvider`: `acp`, `localModel`, `remoteSession`) once per id (`duplicateAgent`). `validateHostConfig(config)` -> the issues `{key, code}` in `providers` order, then forbidden and unknown keys sorted. HOSTS (`hosts`): what each host kind provides, informative and checked against the validator (each must pass). IDENTITY (`identityCases`, `engineViewer`): `member` = the signed-in member with their team role and app access (Exponential); `local` = ONE person on one device and no account (the softcoded app, eDE Local desktops, exported apps): the viewer = `{id: the device uuid, role: owner, access: write}`, so genUI's `recordRefusal` allows every op of every kind policy (`member`, `author`, `owners` all collapse to \"me\"), and records the instance writes carry the device uuid as author; `peer` = a P2P key (Spezl), judged like `member` with the key as id and role `member`. NETWORK (`networkCases`, `networkAllows`): `off` = nothing leaves the device (upstreams, `http.fetch` and a sync transport are refused `offline`); `upstreamsOnly` = the package's declared `upstreams` and the sync transport, never `http.fetch`; `any` = all three (an `http.fetch` still needs its manifest origin and consent: capabilities.json). A refusal is `{allowed: false, reason}`.",
+  providers: {
+    host: { required: true, doc: "HostInfo: host kind, platform, form factor, locale, Engine version" },
+    storage: { required: true, doc: "RecordStore: query, write (writeId), history, subscribe (MemoryRecordStore, SqliteRecordStore = elocal's app-records table, SyncedRecordStore)" },
+    blobs: { required: true, doc: "BlobStore: put/get record files (FsBlobStore, the server's attachments)" },
+    identity: { required: true, doc: "Identity: the viewer (member, local or peer)" },
+    vault: { required: true, doc: "emcp Vault: grants, upstream tokens (Keychain, Keystore, libsecret, sealed server column)" },
+    window: { required: true, doc: "WindowHost: open a screen (window, nav stack, sheet), report lifecycle events" },
+    clock: { required: false, default: "system", doc: "Clock: now (tests pin it)" },
+    zone: { required: false, default: "device", doc: "HostZone: the IANA zone of today/now/month (the team's in Exponential)" },
+    network: { required: false, default: "upstreamsOnly", doc: "NetworkPolicy" },
+    sync: { required: false, default: null, doc: "SyncTransport: pull deltas, push outbox entries (Exponential: Electric in, tRPC out; Spezl: P2P); absent = writes apply locally, no outbox" },
+    agents: { required: false, default: [], list: true, doc: "AgentProvider (Agents): acp, localModel, remoteSession; each gets its tools only as a hub grant" },
+    capabilities: { required: false, default: [], list: true, doc: "Capability: a native tool provider on the in-process hub (capabilities.json)" },
+    consent: { required: false, default: "sheet", doc: "ConsentUi: the Engine's own genUI sheet unless the host paints it (consent.json)" }
+  },
+  forbidden: ["analytics", "crashReporter", "telemetry", "updateChannel", "updates"],
+  networkPolicies: ["off", "upstreamsOnly", "any"],
+  identityKinds: ["member", "local", "peer"],
+  hosts: {
+    exponential: { host: {}, storage: {}, blobs: {}, identity: { kind: "member" }, vault: {}, window: {}, zone: {}, network: "any", sync: {}, agents: [{ id: "acp" }, { id: "remoteSession" }], capabilities: [{ name: "files" }, { name: "share" }, { name: "notifications" }] },
+    softcoded: { host: {}, storage: {}, blobs: {}, identity: { kind: "local" }, vault: {}, window: {}, network: "upstreamsOnly", agents: [{ id: "localModel" }] },
+    ede: { host: {}, storage: {}, blobs: {}, identity: { kind: "local" }, vault: {}, window: {}, network: "any", agents: [{ id: "acp" }], capabilities: [{ name: "files" }, { name: "notifications" }, { name: "shell" }] },
+    spezl: { host: {}, storage: {}, blobs: {}, identity: { kind: "peer" }, vault: {}, window: {}, network: "any", sync: {}, agents: [{ id: "acp" }] },
+    exported: { host: {}, storage: {}, blobs: {}, identity: { kind: "local" }, vault: {}, window: {}, network: "off", capabilities: [{ name: "photos" }, { name: "print" }, { name: "share" }] }
+  },
+  validateCases: [
+    { name: "the minimum", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "local" }, vault: {}, window: {} }, expected: [] },
+    { name: "every required key missing", config: {}, expected: [{ key: "host", code: "missing" }, { key: "storage", code: "missing" }, { key: "blobs", code: "missing" }, { key: "identity", code: "missing" }, { key: "vault", code: "missing" }, { key: "window", code: "missing" }] },
+    { name: "no telemetry, no update channel", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "local" }, vault: {}, window: {}, updates: {}, telemetry: {}, theme: {} }, expected: [{ key: "telemetry", code: "forbidden" }, { key: "theme", code: "unknown" }, { key: "updates", code: "forbidden" }] },
+    { name: "a bad network policy and identity kind", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "guest" }, vault: {}, window: {}, network: "lan" }, expected: [{ key: "identity", code: "invalid" }, { key: "network", code: "invalid" }] },
+    { name: "a capability or agent twice", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "member" }, vault: {}, window: {}, agents: [{ id: "acp" }, { id: "acp" }], capabilities: [{ name: "photos" }, { name: "photos" }] }, expected: [{ key: "agents", code: "duplicateAgent" }, { key: "capabilities", code: "duplicateCapability" }] },
+    { name: "a capability under a reserved or invalid name", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "member" }, vault: {}, window: {}, capabilities: [{ name: "records" }, { name: "Bad_Name" }] }, expected: [{ key: "capabilities", code: "invalidCapability" }] },
+    { name: "an unknown agent provider", config: { host: {}, storage: {}, blobs: {}, identity: { kind: "member" }, vault: {}, window: {}, agents: [{ id: "openclaw" }] }, expected: [{ key: "agents", code: "invalid" }] }
+  ],
+  agentProviders: ["acp", "localModel", "remoteSession"],
+  identityCases: [
+    { name: "local: an author-only update of someone else's record", identity: { kind: "local", deviceId: "d-1" }, policy: { read: "author", create: "owners", update: "author", delete: "owners" }, op: "update", row: { authorId: "u-imported" }, expected: { viewer: { id: "d-1", role: "owner", access: "write" }, refusal: null } },
+    { name: "local: an owners-only delete", identity: { kind: "local", deviceId: "d-1" }, policy: { read: "member", create: "member", update: "author", delete: "owners" }, op: "delete", row: { authorId: "d-1" }, expected: { viewer: { id: "d-1", role: "owner", access: "write" }, refusal: null } },
+    { name: "member: the policy applies", identity: { kind: "member", userId: "u-1", role: "member", access: "write" }, policy: { read: "member", create: "member", update: "author", delete: "author" }, op: "update", row: { authorId: "u-2" }, expected: { viewer: { id: "u-1", role: "member", access: "write" }, refusal: "Only the record's author or a team owner can change it" } },
+    { name: "peer: a key judged as a member", identity: { kind: "peer", key: "pk-9" }, policy: { read: "member", create: "member", update: "author", delete: "author" }, op: "update", row: { authorId: "pk-9" }, expected: { viewer: { id: "pk-9", role: "member", access: "write" }, refusal: null } }
+  ],
+  networkCases: [
+    { policy: "off", target: "upstream", declared: true, expected: { allowed: false, reason: "offline" } },
+    { policy: "off", target: "sync", declared: true, expected: { allowed: false, reason: "offline" } },
+    { policy: "off", target: "http", declared: true, expected: { allowed: false, reason: "offline" } },
+    { policy: "upstreamsOnly", target: "upstream", declared: true, expected: { allowed: true, reason: null } },
+    { policy: "upstreamsOnly", target: "upstream", declared: false, expected: { allowed: false, reason: "notDeclared" } },
+    { policy: "upstreamsOnly", target: "sync", declared: true, expected: { allowed: true, reason: null } },
+    { policy: "upstreamsOnly", target: "http", declared: true, expected: { allowed: false, reason: "network" } },
+    { policy: "any", target: "http", declared: true, expected: { allowed: true, reason: null } },
+    { policy: "any", target: "upstream", declared: false, expected: { allowed: false, reason: "notDeclared" } }
+  ]
+};
+
+// packages/eengine/src/providers.ts
+var PROVIDER_KEYS2 = Object.keys(providers_default.providers);
+var FORBIDDEN_HOST_KEYS2 = providers_default.forbidden;
+var NETWORK_POLICIES2 = providers_default.networkPolicies;
+var IDENTITY_KINDS2 = providers_default.identityKinds;
+var AGENT_PROVIDERS2 = providers_default.agentProviders;
+var isObject = (v) => !!v && typeof v === `object` && !Array.isArray(v);
+function validateHostConfig2(config) {
+  const issues = [];
+  for (const key of PROVIDER_KEYS2) {
+    const def = providers_default.providers[key];
+    const value = config[key];
+    if (value === undefined) {
+      if (def.required)
+        issues.push({ key, code: `missing` });
+      continue;
+    }
+    if (key === `identity` && !(isObject(value) && IDENTITY_KINDS2.includes(value.kind)))
+      issues.push({ key, code: `invalid` });
+    if (key === `network` && !NETWORK_POLICIES2.includes(value))
+      issues.push({ key, code: `invalid` });
+    if (key === `agents`) {
+      const ids = Array.isArray(value) ? value.map((a) => isObject(a) ? a.id : undefined) : null;
+      if (!ids || ids.some((id) => !AGENT_PROVIDERS2.includes(id)))
+        issues.push({ key, code: `invalid` });
+      else if (new Set(ids).size !== ids.length)
+        issues.push({ key, code: `duplicateAgent` });
+    }
+    if (key === `capabilities`) {
+      const names = Array.isArray(value) ? value.map((c) => isObject(c) ? c.name : undefined) : null;
+      if (!names || names.some((n) => typeof n !== `string` || !capabilityNameValid2(n)))
+        issues.push({ key, code: `invalidCapability` });
+      else if (new Set(names).size !== names.length)
+        issues.push({ key, code: `duplicateCapability` });
+    }
+  }
+  const extra = Object.keys(config).filter((k) => !PROVIDER_KEYS2.includes(k)).sort();
+  for (const key of extra)
+    issues.push({ key, code: FORBIDDEN_HOST_KEYS2.includes(key) ? `forbidden` : `unknown` });
+  return issues;
+}
+function engineViewer2(identity) {
+  if (identity.kind === `local`)
+    return { id: identity.deviceId, role: `owner`, access: `write` };
+  if (identity.kind === `peer`)
+    return { id: identity.key, role: `member`, access: `write` };
+  return { id: identity.userId, role: identity.role, access: identity.access ?? `write` };
+}
+var engineRecordRefusal2 = (identity, policy, op, row) => recordRefusal(policy, op, engineViewer2(identity), row);
+function networkAllows2(policy, target, declared) {
+  if (policy === `off`)
+    return { allowed: false, reason: `offline` };
+  if (target === `upstream` && !declared)
+    return { allowed: false, reason: `notDeclared` };
+  if (target === `http` && policy === `upstreamsOnly`)
+    return { allowed: false, reason: `network` };
+  return { allowed: true, reason: null };
+}
+
+export { PROVIDER_KEYS2, FORBIDDEN_HOST_KEYS2, NETWORK_POLICIES2, IDENTITY_KINDS2, AGENT_PROVIDERS2, validateHostConfig2, engineViewer2, engineRecordRefusal2, networkAllows2 };
+
+//# debugId=68437053B3E9A13064756E2164756E21
+//# sourceMappingURL=index-zw0575tv.js.map

package/dist/chunks/index-zw0575tv.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../packages/eengine/src/providers.ts"],
+  "sourcesContent": [
+    "// VAPP-260: what a host hands the Engine (`HostConfig`), the viewer each\n// identity kind yields, and the network policy. Locked by `fixtures/providers.json`.\n\nimport { recordRefusal, type RecordOp, type RecordOwnership, type RecordPolicy, type RecordViewer } from \"@exponential_app/eui/host\"\n\nimport fixture from \"../fixtures/providers.json\" with { type: \"json\" }\nimport { capabilityNameValid } from \"./capabilities\"\n\nexport type ProviderKey = keyof typeof fixture.providers\nexport type NetworkPolicy = `off` | `upstreamsOnly` | `any`\nexport type IdentityKind = `member` | `local` | `peer`\nexport type AgentProviderId = `acp` | `localModel` | `remoteSession`\n\nexport const PROVIDER_KEYS = Object.keys(fixture.providers) as ProviderKey[]\nexport const FORBIDDEN_HOST_KEYS: readonly string[] = fixture.forbidden\nexport const NETWORK_POLICIES = fixture.networkPolicies as readonly NetworkPolicy[]\nexport const IDENTITY_KINDS = fixture.identityKinds as readonly IdentityKind[]\nexport const AGENT_PROVIDERS = fixture.agentProviders as readonly AgentProviderId[]\n\nexport interface HostConfigIssue {\n  key: string\n  code: `missing` | `forbidden` | `unknown` | `invalid` | `duplicateAgent` | `duplicateCapability` | `invalidCapability`\n}\n\nconst isObject = (v: unknown): v is Record<string, unknown> => !!v && typeof v === `object` && !Array.isArray(v)\n\n/** Every problem with a host config: providers in order, then forbidden/unknown keys sorted. */\nexport function validateHostConfig(config: Record<string, unknown>): HostConfigIssue[] {\n  const issues: HostConfigIssue[] = []\n  for (const key of PROVIDER_KEYS) {\n    const def = fixture.providers[key] as { required: boolean }\n    const value = config[key]\n    if (value === undefined) {\n      if (def.required) issues.push({ key, code: `missing` })\n      continue\n    }\n    if (key === `identity` && !(isObject(value) && (IDENTITY_KINDS as readonly unknown[]).includes(value.kind))) issues.push({ key, code: `invalid` })\n    if (key === `network` && !(NETWORK_POLICIES as readonly unknown[]).includes(value)) issues.push({ key, code: `invalid` })\n    if (key === `agents`) {\n      const ids = Array.isArray(value) ? value.map((a) => (isObject(a) ? a.id : undefined)) : null\n      if (!ids || ids.some((id) => !(AGENT_PROVIDERS as readonly unknown[]).includes(id))) issues.push({ key, code: `invalid` })\n      else if (new Set(ids).size !== ids.length) issues.push({ key, code: `duplicateAgent` })\n    }\n    if (key === `capabilities`) {\n      const names = Array.isArray(value) ? value.map((c) => (isObject(c) ? c.name : undefined)) : null\n      if (!names || names.some((n) => typeof n !== `string` || !capabilityNameValid(n))) issues.push({ key, code: `invalidCapability` })\n      else if (new Set(names).size !== names.length) issues.push({ key, code: `duplicateCapability` })\n    }\n  }\n  const extra = Object.keys(config)\n    .filter((k) => !(PROVIDER_KEYS as readonly string[]).includes(k))\n    .sort()\n  for (const key of extra) issues.push({ key, code: FORBIDDEN_HOST_KEYS.includes(key) ? `forbidden` : `unknown` })\n  return issues\n}\n\nexport type EngineIdentity =\n  | { kind: `member`; userId: string; role: string | null; access?: `none` | `read` | `write` }\n  | { kind: `local`; deviceId: string }\n  | { kind: `peer`; key: string }\n\n/** The records viewer of an identity: local = the one owner of everything (\"me\"). */\nexport function engineViewer(identity: EngineIdentity): Required<RecordViewer> {\n  if (identity.kind === `local`) return { id: identity.deviceId, role: `owner`, access: `write` }\n  if (identity.kind === `peer`) return { id: identity.key, role: `member`, access: `write` }\n  return { id: identity.userId, role: identity.role, access: identity.access ?? `write` }\n}\n\n/** Why the viewer of `identity` may not `op` (null = allowed). */\nexport const engineRecordRefusal = (identity: EngineIdentity, policy: RecordPolicy, op: RecordOp, row?: RecordOwnership | null): string | null =>\n  recordRefusal(policy, op, engineViewer(identity), row)\n\n/** May the instance reach `target` under `policy`? `declared` = the package declares the upstream (or the origin). */\nexport function networkAllows(policy: NetworkPolicy, target: `upstream` | `sync` | `http`, declared: boolean): { allowed: boolean; reason: string | null } {\n  if (policy === `off`) return { allowed: false, reason: `offline` }\n  if (target === `upstream` && !declared) return { allowed: false, reason: `notDeclared` }\n  if (target === `http` && policy === `upstreamsOnly`) return { allowed: false, reason: `network` }\n  return { allowed: true, reason: null }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "68437053B3E9A13064756E2164756E21",
+  "names": []
+}

package/dist/consent.js

@@ -0,0 +1,24 @@
+import {
+  CONSENT_COPY2,
+  GRANTS_RECORD_VERSION2,
+  consentAnswer2,
+  grantWrite2,
+  grantsRecord2,
+  grantsOnPackage2,
+  consentSheet2,
+  manageSheet2
+} from "./chunks/index-nrr8x2kq.js";
+import"./chunks/index-md3hz6r2.js";
+export {
+  CONSENT_COPY2 as CONSENT_COPY,
+  GRANTS_RECORD_VERSION2 as GRANTS_RECORD_VERSION,
+  consentAnswer2 as consentAnswer,
+  consentSheet2 as consentSheet,
+  grantWrite2 as grantWrite,
+  grantsOnPackage2 as grantsOnPackage,
+  grantsRecord2 as grantsRecord,
+  manageSheet2 as manageSheet
+};
+
+//# debugId=5375CA8FE54EE02164756E2164756E21
+//# sourceMappingURL=consent.js.map

package/dist/consent.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "5375CA8FE54EE02164756E2164756E21",
+  "names": []
+}