@powerhousedao/shared 6.2.3-dev.9 → 6.2.3-staging.0

package/dist/config-loader-C6dZB_iX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader-C6dZB_iX.js","names":[],"sources":["../connect/runtime-config.ts","../connect/config-loader.ts"],"sourcesContent":["import type {\n  PHConnectRuntimeConfig,\n  PowerhouseConfig,\n  PowerhousePackage,\n} from \"../clis/types.js\";\n\nexport type RuntimePowerhouseConfig = {\n  schemaVersion: 2;\n  packages: PowerhousePackage[];\n  packageRegistryUrl?: string;\n  localPackage: { name: string; version: string } | null;\n  connect: PHConnectRuntimeConfig;\n};\n\n/** Defaults for every field Connect reads at runtime, merged into the\n * `connect.*` block at boot; also the dist emitter's and the scaffold's base. */\nexport const DEFAULT_CONNECT_CONFIG: PHConnectRuntimeConfig = {\n  branding: {\n    appName: \"Powerhouse Connect\",\n    homeBackground: null,\n  },\n  app: {\n    logLevel: \"info\",\n    basePath: \"/\",\n    offline: true,\n    studioMode: false,\n  },\n  ai: {\n    assistantEnabled: false,\n  },\n  packages: {\n    externalEnabled: true,\n    liveReload: false,\n  },\n  drives: {\n    allowAddDrive: true,\n    defaultDrives: [],\n    sections: {\n      remote: { enabled: true, allowAdd: true, allowDelete: true },\n      local: { enabled: true, allowAdd: true, allowDelete: true },\n    },\n  },\n  renown: {\n    url: \"https://www.renown.id\",\n    networkId: \"eip155\",\n    chainId: 1,\n  },\n  sentry: {\n    // `dsn: null` is the disabled-Sentry state — the SPA never loads the\n    // Sentry SDK chunk. Override via `ph connect config --sentry-dsn ...`\n    // or by including `connect.sentry.dsn` in PH_CONNECT_CONFIG_JSON.\n    dsn: null,\n    env: \"dev\",\n    tracing: false,\n  },\n  openPanel: {\n    // An empty `clientId` keeps OpenPanel disabled. Enable it per deploy by\n    // including `connect.openPanel.clientId` in PH_CONNECT_CONFIG_JSON.\n    // `apiUrl` has no default: unset means OpenPanel's hosted API.\n    clientId: \"\",\n    trackUiEvents: true,\n    trackOperations: true,\n  },\n  instance: {\n    namespace: null,\n    reactorWorker: false,\n  },\n  reactor: {\n    featureFlags: {\n      documentDecisions: false,\n      authEnforcement: false,\n      authGroups: false,\n      authConditions: false,\n    },\n    createSignaturePolicy: \"v2-required\",\n    unsupportedStoredDocuments: \"refuse\",\n  },\n};\n\nexport function buildRuntimeConfig(\n  source: Pick<PowerhouseConfig, \"packages\" | \"connect\" | \"packageRegistryUrl\">,\n  projectInfo: { name: string; version: string } | null,\n): RuntimePowerhouseConfig {\n  const result: RuntimePowerhouseConfig = {\n    schemaVersion: 2,\n    packages: source.packages ?? [],\n    localPackage: projectInfo,\n    connect: source.connect ?? {},\n  };\n  if (\n    typeof source.packageRegistryUrl === \"string\" &&\n    source.packageRegistryUrl !== \"\"\n  ) {\n    result.packageRegistryUrl = source.packageRegistryUrl;\n  }\n  return result;\n}\n","// Environment-neutral config loader. Wraps a `ConfigAdapter` (the IO layer)\n// with in-process caching and deep-merge-with-defaults reads.\n//\n// No validation. The loader trusts that whatever bytes the adapter returns\n// can be merged into the default Connect config; missing or partial fields\n// fall back to DEFAULT_CONNECT_CONFIG, so the SPA always sees a complete\n// `connect.*` block.\n//\n// Top-level fields outside `connect.*` (e.g. `studio.port` in the source\n// powerhouse.config.json) pass through untouched on both read and write.\n// They're not Connect's concern, but a write-back round-trip preserves\n// them so editing tools don't accidentally drop them.\n\nimport { isPlainObject } from \"remeda\";\nimport type {\n  PHConnectRuntimeConfig,\n  PowerhouseConfig,\n} from \"../clis/types.js\";\nimport { DEFAULT_CONNECT_CONFIG } from \"./runtime-config.js\";\n\n/** Recursive Partial. Arrays are leaves — `write({ packages: [...] })`\n * replaces the array, it doesn't merge. */\nexport type DeepPartial<T> =\n  T extends Array<infer U>\n    ? Array<U>\n    : T extends object\n      ? { [K in keyof T]?: DeepPartial<T[K]> }\n      : T;\n\n/**\n * Shape returned by `ConfigLoader.read()`. The loader is Connect-scoped:\n * it guarantees `connect` is present and fully populated from\n * DEFAULT_CONNECT_CONFIG, but lets any other top-level fields pass\n * through unchanged so source-config-only fields (studio, reactor, auth,\n * documentModelsDir, etc.) survive a read+write round-trip.\n */\nexport type ConfigShape = Record<string, unknown> & {\n  connect: PHConnectRuntimeConfig;\n};\n\n/**\n * Abstract IO layer for `powerhouse.config.json`.\n *\n * Implementations decide where bytes come from and go to. The shipped\n * adapter is `JsonConfigAdapter` (reads via fetch in the browser, fs in\n * Node; writes via fs in Node, throws in the browser). Future adapters\n * (remote-JSON, GraphQL) plug in without changing the loader or any\n * consumer.\n */\nexport interface ConfigAdapter {\n  /** Read raw JSON-parsed payload from the backing store. */\n  read(): Promise<unknown>;\n  /** Persist a fully-formed config. */\n  write(next: ConfigShape): Promise<void>;\n  /** Human-readable description used in errors and logs. */\n  readonly source: string;\n}\n\n/**\n * Deep-merge `patch` into `base`. Object fields recurse; arrays and\n * primitives replace. `undefined` in patch leaves the base value\n * untouched (no unset). `null` in patch overwrites with null.\n *\n * Exported for unit tests; consumers use ConfigLoader.write() which\n * applies this internally.\n */\nexport function deepMerge<T>(base: T, patch: DeepPartial<T>): T {\n  if (!isPlainObject(base) || !isPlainObject(patch)) {\n    return patch as T;\n  }\n  const result: Record<string, unknown> = { ...base };\n  for (const [key, patchValue] of Object.entries(patch)) {\n    if (patchValue === undefined) continue;\n    const baseValue = result[key];\n    if (isPlainObject(baseValue) && isPlainObject(patchValue)) {\n      result[key] = deepMerge(\n        baseValue,\n        patchValue as DeepPartial<typeof baseValue>,\n      );\n    } else {\n      result[key] = patchValue;\n    }\n  }\n  return result as T;\n}\n\n/**\n * The effective `connect.*` block of a source `powerhouse.config.json`:\n * defaults < project-wide settings Connect follows < `connect.*`. So\n * `connect.app.workflowsEnabled` falls back to `workflows.enabled`, and\n * wins when set.\n */\nexport function resolveSourceConnect(\n  source: Pick<PowerhouseConfig, \"connect\" | \"workflows\">,\n  defaults: PHConnectRuntimeConfig = DEFAULT_CONNECT_CONFIG,\n): PHConnectRuntimeConfig {\n  const projectWide = deepMerge(defaults, {\n    app: { workflowsEnabled: source.workflows?.enabled },\n  });\n  return deepMerge(projectWide, source.connect ?? {});\n}\n\n/**\n * Pluggable loader on top of a `ConfigAdapter`.\n *\n * Responsibilities:\n *  - merge-with-defaults on read (so consumers never see a partial connect block)\n *  - in-process caching (call `invalidate()` to force re-read)\n *  - deep-merge for partial writes; writes the merged whole back through the adapter\n *\n * The cache is module-instance scoped — every `new ConfigLoader(...)` has\n * its own cache. The browser SPA constructs the loader once at boot; the\n * CLI typically constructs a fresh loader per command.\n */\nexport class ConfigLoader {\n  private cache: ConfigShape | undefined;\n\n  constructor(\n    private readonly adapter: ConfigAdapter,\n    private readonly defaults: PHConnectRuntimeConfig = DEFAULT_CONNECT_CONFIG,\n  ) {}\n\n  /** Returns the config with the default connect block merged in.\n   * Cached after the first successful call. */\n  async read(): Promise<ConfigShape> {\n    if (this.cache) return this.cache;\n    const raw = await this.adapter.read();\n    const obj = isPlainObject(raw) ? raw : {};\n    const connectRaw = isPlainObject(obj.connect) ? obj.connect : {};\n    this.cache = {\n      ...obj,\n      connect: deepMerge(\n        this.defaults,\n        connectRaw as DeepPartial<PHConnectRuntimeConfig>,\n      ),\n    };\n    return this.cache;\n  }\n\n  /**\n   * Returns the cached config synchronously. Throws if `read()` has not\n   * resolved yet — matches Connect's `getRuntimeConfig()` shape.\n   */\n  getCached(): ConfigShape {\n    if (!this.cache) {\n      throw new Error(\n        `ConfigLoader (${this.adapter.source}): cache empty; call read() first.`,\n      );\n    }\n    return this.cache;\n  }\n\n  /** Drop the in-memory cache. Next `read()` re-fetches from the adapter. */\n  invalidate(): void {\n    this.cache = undefined;\n  }\n\n  /**\n   * Deep-merge `patch` into the current config and persist via the adapter.\n   * Returns the new full config (also updates the cache). Arrays in `patch`\n   * replace — they do NOT append.\n   */\n  async write(patch: DeepPartial<ConfigShape>): Promise<ConfigShape> {\n    const current = await this.read();\n    const next = deepMerge(current, patch);\n    await this.adapter.write(next);\n    this.cache = next;\n    return next;\n  }\n}\n"],"mappings":";;;;AAgBA,MAAa,yBAAiD;CAC5D,UAAU;EACR,SAAS;EACT,gBAAgB;CAClB;CACA,KAAK;EACH,UAAU;EACV,UAAU;EACV,SAAS;EACT,YAAY;CACd;CACA,IAAI,EACF,kBAAkB,MACpB;CACA,UAAU;EACR,iBAAiB;EACjB,YAAY;CACd;CACA,QAAQ;EACN,eAAe;EACf,eAAe,CAAC;EAChB,UAAU;GACR,QAAQ;IAAE,SAAS;IAAM,UAAU;IAAM,aAAa;GAAK;GAC3D,OAAO;IAAE,SAAS;IAAM,UAAU;IAAM,aAAa;GAAK;EAC5D;CACF;CACA,QAAQ;EACN,KAAK;EACL,WAAW;EACX,SAAS;CACX;CACA,QAAQ;EAIN,KAAK;EACL,KAAK;EACL,SAAS;CACX;CACA,WAAW;EAIT,UAAU;EACV,eAAe;EACf,iBAAiB;CACnB;CACA,UAAU;EACR,WAAW;EACX,eAAe;CACjB;CACA,SAAS;EACP,cAAc;GACZ,mBAAmB;GACnB,iBAAiB;GACjB,YAAY;GACZ,gBAAgB;EAClB;EACA,uBAAuB;EACvB,4BAA4B;CAC9B;AACF;AAEA,SAAgB,mBACd,QACA,aACyB;CACzB,MAAM,SAAkC;EACtC,eAAe;EACf,UAAU,OAAO,YAAY,CAAC;EAC9B,cAAc;EACd,SAAS,OAAO,WAAW,CAAC;CAC9B;CACA,IACE,OAAO,OAAO,uBAAuB,YACrC,OAAO,uBAAuB,IAE9B,OAAO,qBAAqB,OAAO;CAErC,OAAO;AACT;;;;;;;;;;;AC9BA,SAAgB,UAAa,MAAS,OAA0B;CAC9D,IAAI,CAAC,cAAc,IAAI,KAAK,CAAC,cAAc,KAAK,GAC9C,OAAO;CAET,MAAM,SAAkC,EAAE,GAAG,KAAK;CAClD,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,KAAK,GAAG;EACrD,IAAI,eAAe,KAAA,GAAW;EAC9B,MAAM,YAAY,OAAO;EACzB,IAAI,cAAc,SAAS,KAAK,cAAc,UAAU,GACtD,OAAO,OAAO,UACZ,WACA,UACF;OAEA,OAAO,OAAO;CAElB;CACA,OAAO;AACT;;;;;;;AAQA,SAAgB,qBACd,QACA,WAAmC,wBACX;CAIxB,OAAO,UAHa,UAAU,UAAU,EACtC,KAAK,EAAE,kBAAkB,OAAO,WAAW,QAAQ,EACrD,CAC2B,GAAG,OAAO,WAAW,CAAC,CAAC;AACpD;;;;;;;;;;;;;AAcA,IAAa,eAAb,MAA0B;CAIL;CACA;CAJnB;CAEA,YACE,SACA,WAAoD,wBACpD;EAFiB,KAAA,UAAA;EACA,KAAA,WAAA;CAChB;;;CAIH,MAAM,OAA6B;EACjC,IAAI,KAAK,OAAO,OAAO,KAAK;EAC5B,MAAM,MAAM,MAAM,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,cAAc,GAAG,IAAI,MAAM,CAAC;EACxC,MAAM,aAAa,cAAc,IAAI,OAAO,IAAI,IAAI,UAAU,CAAC;EAC/D,KAAK,QAAQ;GACX,GAAG;GACH,SAAS,UACP,KAAK,UACL,UACF;EACF;EACA,OAAO,KAAK;CACd;;;;;CAMA,YAAyB;EACvB,IAAI,CAAC,KAAK,OACR,MAAM,IAAI,MACR,iBAAiB,KAAK,QAAQ,OAAO,mCACvC;EAEF,OAAO,KAAK;CACd;;CAGA,aAAmB;EACjB,KAAK,QAAQ,KAAA;CACf;;;;;;CAOA,MAAM,MAAM,OAAuD;EAEjE,MAAM,OAAO,UAAU,MADD,KAAK,KAAK,GACA,KAAK;EACrC,MAAM,KAAK,QAAQ,MAAM,IAAI;EAC7B,KAAK,QAAQ;EACb,OAAO;CACT;AACF"}

package/dist/connect/config-loader.d.ts

@@ -1,9 +1,8 @@
-import { D as PHConnectRuntimeConfig } from "../types-BIoOWpOT.js";
-
+import { L as PowerhouseConfig, O as PHConnectRuntimeConfig } from "../types-CmeoQg_J.js";
 //#region connect/config-loader.d.ts
 /** Recursive Partial. Arrays are leaves — `write({ packages: [...] })`
  * replaces the array, it doesn't merge. */
-type DeepPartial<T> = T extends Array<infer U> ? Array<U> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+export type DeepPartial<T> = T extends Array<infer U> ? Array<U> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]>; } : T;
 /**
  * Shape returned by `ConfigLoader.read()`. The loader is Connect-scoped:
  * it guarantees `connect` is present and fully populated from
@@ -11,7 +10,7 @@ type DeepPartial<T> = T extends Array<infer U> ? Array<U> : T extends object ? {
  * through unchanged so source-config-only fields (studio, reactor, auth,
  * documentModelsDir, etc.) survive a read+write round-trip.
  */
-type ConfigShape = Record<string, unknown> & {
+export type ConfigShape = Record<string, unknown> & {
   connect: PHConnectRuntimeConfig;
 };
 /**
@@ -23,7 +22,7 @@ type ConfigShape = Record<string, unknown> & {
  * (remote-JSON, GraphQL) plug in without changing the loader or any
  * consumer.
  */
-interface ConfigAdapter {
+export interface ConfigAdapter {
   /** Read raw JSON-parsed payload from the backing store. */
   read(): Promise<unknown>;
   /** Persist a fully-formed config. */
@@ -39,7 +38,14 @@ interface ConfigAdapter {
  * Exported for unit tests; consumers use ConfigLoader.write() which
  * applies this internally.
  */
-declare function deepMerge<T>(base: T, patch: DeepPartial<T>): T;
+export declare function deepMerge<T>(base: T, patch: DeepPartial<T>): T;
+/**
+ * The effective `connect.*` block of a source `powerhouse.config.json`:
+ * defaults < project-wide settings Connect follows < `connect.*`. So
+ * `connect.app.workflowsEnabled` falls back to `workflows.enabled`, and
+ * wins when set.
+ */
+export declare function resolveSourceConnect(source: Pick<PowerhouseConfig, "connect" | "workflows">, defaults?: PHConnectRuntimeConfig): PHConnectRuntimeConfig;
 /**
  * Pluggable loader on top of a `ConfigAdapter`.
  *
@@ -52,7 +58,7 @@ declare function deepMerge<T>(base: T, patch: DeepPartial<T>): T;
  * its own cache. The browser SPA constructs the loader once at boot; the
  * CLI typically constructs a fresh loader per command.
  */
-declare class ConfigLoader {
+export declare class ConfigLoader {
   private readonly adapter;
   private readonly defaults;
   private cache;
@@ -75,5 +81,5 @@ declare class ConfigLoader {
   write(patch: DeepPartial<ConfigShape>): Promise<ConfigShape>;
 }
 //#endregion
-export { ConfigAdapter, ConfigLoader, ConfigShape, DeepPartial, deepMerge };
+export {};
 //# sourceMappingURL=config-loader.d.ts.map

package/dist/connect/config-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-loader.d.ts","names":[],"sources":["../../connect/config-loader.ts"],"mappings":";;;;;KAmBY,WAAA,MACV,CAAA,SAAU,KAAA,YACN,KAAA,CAAM,CAAA,IACN,CAAA,gCACgB,CAAA,IAAK,WAAA,CAAY,CAAA,CAAE,CAAA,OACjC,CAAA;;;;;;;;KASI,WAAA,GAAc,MAAA;EACxB,OAAA,EAAS,sBAAA;AAAA;;;;;;;;;;UAYM,aAAA;EAvBK;EAyBpB,IAAA,IAAQ,OAAA;EAzB6B;EA2BrC,KAAA,CAAM,IAAA,EAAM,WAAA,GAAc,OAAA;EA1BpB;EAAA,SA4BG,MAAA;AAAA;AAnBX;;;;;;;;AAAA,iBA8BgB,SAAA,GAAA,CAAa,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,WAAA,CAAY,CAAA,IAAK,CAAA;AAjB9D;;;;;;;;;;;;AAAA,cAiDa,YAAA;EAAA,iBAIQ,OAAA;EAAA,iBACA,QAAA;EAAA,QAJX,KAAA;cAGW,OAAA,EAAS,aAAA,EACT,QAAA,GAAU,sBAAA;EArCf;;EA0CR,IAAA,CAAA,GAAQ,OAAA,CAAQ,WAAA;EA1CW;;;;EA6DjC,SAAA,CAAA,GAAa,WAAA;EA7DgD;EAuE7D,UAAA,CAAA;EAvEiC;;;;;EAgF3B,KAAA,CAAM,KAAA,EAAO,WAAA,CAAY,WAAA,IAAe,OAAA,CAAQ,WAAA;AAAA"}
+{"version":3,"file":"config-loader.d.ts","names":[],"sources":["../../connect/config-loader.ts"],"mappings":";;;;YAsBY,YAAY,KACtB,UAAU,YAAY,KAClB,MAAM,KACN,sBACK,WAAW,KAAK,YAAY,EAAE,SACjC;;;;;;;;YASI,cAAc;EACxB,SAAS;;;;;;;;;;;iBAYM;;EAEf,QAAQ;;EAER,MAAM,MAAM,cAAc;;WAEjB;;;;;;;;;;wBAWK,UAAU,GAAG,MAAM,GAAG,OAAO,YAAY,KAAK;;;;;;;wBA0B9C,qBACd,QAAQ,KAAK,4CACb,WAAU,yBACT;;;;;;;;;;;;;qBAmBU;mBAIQ;mBACA;UAJX;EAER,YACmB,SAAS,eACT,WAAU;;;EAKvB,QAAQ,QAAQ;;;;;EAmBtB,aAAa;;EAUb;;;;;;EASM,MAAM,OAAO,YAAY,eAAe,QAAQ"}

package/dist/connect/config-loader.js

@@ -1,2 +1,2 @@
-import { n as deepMerge, t as ConfigLoader } from "../config-loader-B845Hidf.js";
-export { ConfigLoader, deepMerge };
+import { n as deepMerge, r as resolveSourceConnect, t as ConfigLoader } from "../config-loader-C6dZB_iX.js";
+export { ConfigLoader, deepMerge, resolveSourceConnect };

package/dist/connect/index.d.ts

@@ -1,8 +1,22 @@
-import { D as PHConnectRuntimeConfig, I as PowerhouseConfig, L as PowerhousePackage, S as PHConnectPwaUrlPattern, _ as PHConnectPwaCacheStrategy, b as PHConnectPwaManifest, g as PHConnectPwa, v as PHConnectPwaFileHandler, x as PHConnectPwaRuntimeCaching, y as PHConnectPwaIcon } from "../types-BIoOWpOT.js";
-import { ConfigAdapter, ConfigLoader, ConfigShape, DeepPartial, deepMerge } from "./config-loader.js";
+import { C as PHConnectPwaUrlPattern, L as PowerhouseConfig, O as PHConnectRuntimeConfig, R as PowerhousePackage, S as PHConnectPwaRuntimeCaching, _ as PHConnectPwa, b as PHConnectPwaIcon, v as PHConnectPwaCacheStrategy, x as PHConnectPwaManifest, y as PHConnectPwaFileHandler } from "../types-CmeoQg_J.js";
+import { ConfigAdapter, ConfigLoader, ConfigShape, DeepPartial, deepMerge, resolveSourceConnect } from "./config-loader.js";
 import { JsonConfigAdapter, JsonConfigAdapterOptions } from "./json-adapter.js";
 import { z } from "zod";
-
+//#region connect/dynamic-base.d.ts
+/**
+ * The base a dynamic-base Connect build is compiled against. The build emits
+ * this literal wherever a base-relative URL would go, and the serving layer
+ * (the dynamic-base vite plugin at build time, the connect proxy at serve
+ * time) rewrites it to the base the app is actually deployed under.
+ *
+ * It lives here, in the browser-safe shared package, rather than in
+ * `@powerhousedao/builder-tools`, because both the node-only build toolchain
+ * and Connect's own browser code need it. Importing builder-tools from app
+ * code pulls the whole build toolchain (and its node-only `read-pkg`
+ * dependency) into the browser graph.
+ */
+export declare const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
+//#endregion
 //#region connect/env-config.d.ts
 /**
  * Build-time configuration schema
@@ -19,36 +33,36 @@ declare const buildEnvSchema: z.ZodObject<{
  * build-metadata + analytics-processor toggles live here; all Connect
  * runtime config lives in `powerhouse.config.json`.
  */
-declare const runtimeEnvSchema: z.ZodObject<{
+export declare const runtimeEnvSchema: z.ZodObject<{
   PH_CONNECT_VERSION: z.ZodDefault<z.ZodString>;
   PH_CONNECT_CLI_VERSION: z.ZodOptional<z.ZodString>;
   PH_CONNECT_DIFF_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-    true: "true";
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_DRIVE_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_DRIVE_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_EXTERNAL_ANALYTICS_PROCESSORS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_EXTERNAL_ANALYTICS_PROCESSORS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
+    true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
   PH_CONNECT_OPENPANEL_CLIENT_ID: z.ZodOptional<z.ZodString>;
   PH_CONNECT_OPENPANEL_API_URL: z.ZodOptional<z.ZodString>;
   PH_CONNECT_OPENPANEL_TRACK_UI_EVENTS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-    true: "true";
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_OPENPANEL_TRACK_OPERATIONS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_OPENPANEL_TRACK_OPERATIONS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
+    true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
 }, z.core.$strip>;
 /**
  * Complete environment schema (build + runtime)
  */
-declare const connectEnvSchema: z.ZodObject<{
+export declare const connectEnvSchema: z.ZodObject<{
   PH_PACKAGES: z.ZodOptional<z.ZodString>;
   PH_LOCAL_PACKAGE: z.ZodOptional<z.ZodString>;
   PH_SENTRY_AUTH_TOKEN: z.ZodOptional<z.ZodString>;
@@ -57,38 +71,38 @@ declare const connectEnvSchema: z.ZodObject<{
   PH_CONNECT_VERSION: z.ZodDefault<z.ZodString>;
   PH_CONNECT_CLI_VERSION: z.ZodOptional<z.ZodString>;
   PH_CONNECT_DIFF_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-    true: "true";
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_DRIVE_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_DRIVE_ANALYTICS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_EXTERNAL_ANALYTICS_PROCESSORS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_EXTERNAL_ANALYTICS_PROCESSORS_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
+    true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
   PH_CONNECT_OPENPANEL_CLIENT_ID: z.ZodOptional<z.ZodString>;
   PH_CONNECT_OPENPANEL_API_URL: z.ZodOptional<z.ZodString>;
   PH_CONNECT_OPENPANEL_TRACK_UI_EVENTS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-    true: "true";
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
-  PH_CONNECT_OPENPANEL_TRACK_OPERATIONS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
+  PH_CONNECT_OPENPANEL_TRACK_OPERATIONS: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
     false: "false";
-  }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
+    true: "true";
+  }>]>, z.ZodTransform<boolean, "false" | "true" | boolean>>>;
 }, z.core.$strip>;
 /**
  * Inferred TypeScript types from schemas
  */
-type ConnectBuildEnv = z.infer<typeof buildEnvSchema>;
-type ConnectRuntimeEnv = z.infer<typeof runtimeEnvSchema>;
-type ConnectEnv = z.infer<typeof connectEnvSchema>;
+export type ConnectBuildEnv = z.infer<typeof buildEnvSchema>;
+export type ConnectRuntimeEnv = z.infer<typeof runtimeEnvSchema>;
+export type ConnectEnv = z.infer<typeof connectEnvSchema>;
 /**
  * Options for loading environment variables
  */
-interface LoadEnvOptions {
+export interface LoadEnvOptions {
   /**
    * Environment variables from process.env (highest priority)
    */
@@ -107,7 +121,7 @@ interface LoadEnvOptions {
  * @param options - Environment sources in priority order
  * @returns Validated and typed environment configuration
  */
-declare function loadConnectEnv(options?: LoadEnvOptions): ConnectEnv;
+export declare function loadConnectEnv(options?: LoadEnvOptions): ConnectEnv;
 /**
  * Loads only runtime environment variables (build metadata + Sentry +
  * analytics-processor toggles — everything in the Connect runtime schema
@@ -116,7 +130,7 @@ declare function loadConnectEnv(options?: LoadEnvOptions): ConnectEnv;
  * @param options - Environment sources in priority order
  * @returns Validated runtime environment configuration
  */
-declare function loadRuntimeEnv(options?: LoadEnvOptions): ConnectRuntimeEnv;
+export declare function loadRuntimeEnv(options?: LoadEnvOptions): ConnectRuntimeEnv;
 /**
  * Safely sets Connect environment variables with validation.
  * Invalid values will log a warning and be skipped.
@@ -131,7 +145,7 @@ declare function loadRuntimeEnv(options?: LoadEnvOptions): ConnectRuntimeEnv;
  * });
  * ```
  */
-declare function setConnectEnv(values: Partial<ConnectEnv>): void;
+export declare function setConnectEnv(values: Partial<ConnectEnv>): void;
 /**
  * Normalizes a base path to ensure it:
  * - Starts with a forward slash (/)
@@ -148,13 +162,13 @@ declare function setConnectEnv(values: Partial<ConnectEnv>): void;
  * normalizeBasePath('/') // '/'
  * normalizeBasePath('') // '/'
  */
-declare function normalizeBasePath(basePath: string): string;
+export declare function normalizeBasePath(basePath: string): string;
 /**
  * Base storage namespace for a Connect instance served at the root of an
  * origin. Kept as a literal so root deployments resolve to a byte-identical
  * value with no migration.
  */
-declare const ROOT_STORAGE_NAMESPACE = "reactor";
+export declare const ROOT_STORAGE_NAMESPACE = "reactor";
 /**
  * Derives the origin-scoped storage namespace from a Connect base path.
  *
@@ -177,12 +191,13 @@ declare const ROOT_STORAGE_NAMESPACE = "reactor";
  * getStorageNamespace('/') // 'reactor'
  * getStorageNamespace('/reactor-project/vetra-studio/') // 'reactor--reactor-project-vetra-studio'
  */
-declare function getStorageNamespace(basePath: string): string;
+export declare function getStorageNamespace(basePath: string): string;
 //#endregion
 //#region connect/pwa-config.d.ts
 /** A labelled PWA fragment, so merge diagnostics can name the contributor. */
-type PwaContribution = {
-  /** Human-readable origin (package name, or the project config file). */source: string;
+export type PwaContribution = {
+  /** Human-readable origin (package name, or the project config file). */
+  source: string;
   config: PHConnectPwa;
 };
 type IconLike = {
@@ -191,7 +206,7 @@ type IconLike = {
   purpose?: string | readonly string[];
 };
 /** Concatenate icons, keeping the first occurrence of each (src,sizes,purpose). */
-declare function dedupeIcons<T extends IconLike>(icons: T[]): T[];
+export declare function dedupeIcons<T extends IconLike>(icons: T[]): T[];
 /**
  * Concatenate file handlers, keeping the first occurrence of each entry.
  * Deduped on the WHOLE entry (canonical JSON) rather than any single field:
@@ -200,15 +215,15 @@ declare function dedupeIcons<T extends IconLike>(icons: T[]): T[];
  * fragment arriving via two layers is a duplicate. Structural, so it also
  * works on the vite-plugin-pwa handler shape in builder-tools.
  */
-declare function dedupeFileHandlers<T extends object>(handlers: T[]): T[];
+export declare function dedupeFileHandlers<T extends object>(handlers: T[]): T[];
 /** Fold a manifest's top-level `category` string into a PWA config as a
  * `categories: [category]` entry. PWA `categories` is DERIVED from the
  * `category` field of every contributing `powerhouse.manifest.json` (never
  * authored under `pwa`); `mergePwaConfig`/`mergeManifest` then union them
  * across contributors. No-op when there is no usable category. */
-declare function withInferredCategory(config: PHConnectPwa, category: unknown): PHConnectPwa;
+export declare function withInferredCategory(config: PHConnectPwa, category: unknown): PHConnectPwa;
 /** Order-preserving string union (used for the precache glob lists). */
-declare function unionStrings(base: string[] | undefined, extra: string[]): string[];
+export declare function unionStrings(base: string[] | undefined, extra: string[]): string[];
 /**
  * Fold the build-time-known package PWA fragments and the project's
  * `connect.pwa` block into one effective fragment. Precedence is
@@ -223,10 +238,10 @@ declare function unionStrings(base: string[] | undefined, extra: string[]): stri
  * by setting that field in `connect.pwa`, which both wins and silences the
  * warning.
  */
-declare function mergePwaConfig(packageContributions: PwaContribution[], projectConfig?: PHConnectPwa, onWarn?: (message: string) => void): PHConnectPwa;
+export declare function mergePwaConfig(packageContributions: PwaContribution[], projectConfig?: PHConnectPwa, onWarn?: (message: string) => void): PHConnectPwa;
 /** A serialisable URL pattern as Workbox consumes it: strings pass through
  * verbatim, `{ source, flags }` is rebuilt into a RegExp. */
-declare function toRegExpOrString(pattern: PHConnectPwaUrlPattern): string | RegExp;
+export declare function toRegExpOrString(pattern: PHConnectPwaUrlPattern): string | RegExp;
 //#endregion
 //#region connect/pwa-manifest.d.ts
 /**
@@ -237,15 +252,15 @@ declare function toRegExpOrString(pattern: PHConnectPwaUrlPattern): string | Reg
  * webmanifest is served dynamically and never rewritten by the dynamic-base
  * plugin) — same trick as the base start_url/scope.
  */
-declare const PWA_FILE_HANDLER_ACTION = ".";
-declare const PWA_IDB_NAME = "ph-pwa";
-declare const PWA_IDB_STORE = "fragments";
-declare const PWA_IDB_KEY = "merged";
-declare const PWA_IDB_VERSION = 1;
+export declare const PWA_FILE_HANDLER_ACTION = ".";
+export declare const PWA_IDB_NAME = "ph-pwa";
+export declare const PWA_IDB_STORE = "fragments";
+export declare const PWA_IDB_KEY = "merged";
+export declare const PWA_IDB_VERSION = 1;
 /** The subset of a web-app manifest this module reads/writes, plus an index
  * signature so untouched fields (name, theme_color, launch_handler, …) pass
  * through verbatim. */
-interface PwaWebManifest {
+export interface PwaWebManifest {
   icons?: PHConnectPwaIcon[];
   file_handlers?: (PHConnectPwaFileHandler & {
     action?: string;
@@ -272,13 +287,13 @@ interface PwaWebManifest {
  *
  * The Connect-owned file-handler action is injected idempotently.
  */
-declare function mergeManifest(base: PwaWebManifest, fragment: PHConnectPwaManifest | undefined, opts?: {
+export declare function mergeManifest(base: PwaWebManifest, fragment: PHConnectPwaManifest | undefined, opts?: {
   scalarPolicy?: "base-wins" | "fragment-wins";
   protectedScalars?: readonly string[];
 }): PwaWebManifest;
 //#endregion
 //#region connect/runtime-config.d.ts
-type RuntimePowerhouseConfig = {
+export type RuntimePowerhouseConfig = {
   schemaVersion: 2;
   packages: PowerhousePackage[];
   packageRegistryUrl?: string;
@@ -290,14 +305,14 @@ type RuntimePowerhouseConfig = {
 };
 /** Defaults for every field Connect reads at runtime, merged into the
  * `connect.*` block at boot; also the dist emitter's and the scaffold's base. */
-declare const DEFAULT_CONNECT_CONFIG: PHConnectRuntimeConfig;
-declare function buildRuntimeConfig(source: Pick<PowerhouseConfig, "packages" | "connect" | "packageRegistryUrl">, projectInfo: {
+export declare const DEFAULT_CONNECT_CONFIG: PHConnectRuntimeConfig;
+export declare function buildRuntimeConfig(source: Pick<PowerhouseConfig, "packages" | "connect" | "packageRegistryUrl">, projectInfo: {
   name: string;
   version: string;
 } | null): RuntimePowerhouseConfig;
 //#endregion
 //#region connect/schema-fragments.d.ts
-declare const powerhousePackageSchema: {
+export declare const powerhousePackageSchema: {
   readonly type: "object";
   readonly additionalProperties: false;
   readonly required: readonly ["packageName"];
@@ -321,7 +336,7 @@ declare const powerhousePackageSchema: {
     };
   };
 };
-declare const phConnectRuntimeConfigSchema: {
+export declare const phConnectRuntimeConfigSchema: {
   readonly type: "object";
   readonly additionalProperties: false;
   readonly description: "Connect-specific UI customisations. All fields optional; omit the section entirely for default behaviour.";
@@ -367,6 +382,10 @@ declare const phConnectRuntimeConfigSchema: {
           readonly description: "Studio mode. Enables builder-only capabilities: Connect loads the vetra package and exposes DocumentModel (and vetra spec types) as creatable documents. Forced on by `ph vetra` / `ph connect studio`; false by default.";
           readonly default: false;
         };
+        readonly workflowsEnabled: {
+          readonly type: "boolean";
+          readonly description: "Powerhouse workflows in Connect. When true the tab loads the @powerhousedao/workflow package (workflow + connection documents, their editors and Workflow Studio) and the reactor worker registers its document models. Falls back to the top-level `workflows.enabled`; set it to override that for Connect. Independent of studioMode. False when neither is set.";
+        };
       };
     };
     readonly ai: {
@@ -609,6 +628,32 @@ declare const phConnectRuntimeConfigSchema: {
         };
       };
     };
+    readonly openPanel: {
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly description: "OpenPanel product analytics. Set `clientId` to enable; an empty `clientId` disables it. Events are only sent after the user accepts analytics cookies. Takes precedence over the build-time PH_CONNECT_OPENPANEL_* env vars.";
+      readonly properties: {
+        readonly clientId: {
+          readonly type: "string";
+          readonly description: "OpenPanel client id. Empty string disables OpenPanel entirely.";
+          readonly default: "";
+        };
+        readonly apiUrl: {
+          readonly type: "string";
+          readonly description: "OpenPanel API URL for self-hosted instances (e.g. 'https://openpanel.example/api'). Omit to use OpenPanel's hosted API.";
+        };
+        readonly trackUiEvents: {
+          readonly type: "boolean";
+          readonly description: "Track UI events.";
+          readonly default: true;
+        };
+        readonly trackOperations: {
+          readonly type: "boolean";
+          readonly description: "Track document operations.";
+          readonly default: true;
+        };
+      };
+    };
     readonly instance: {
       readonly type: "object";
       readonly additionalProperties: false;
@@ -659,6 +704,18 @@ declare const phConnectRuntimeConfigSchema: {
             };
           };
         };
+        readonly createSignaturePolicy: {
+          readonly type: "string";
+          readonly enum: readonly ["legacy", "v2-required"];
+          readonly description: "What new documents are created as. `v2-required` documents accept only v2 action signatures and take content-addressed ids; set `legacy` while any peer Connect syncs with predates them. Existing documents keep their policy.";
+          readonly default: "v2-required";
+        };
+        readonly unsupportedStoredDocuments: {
+          readonly type: "string";
+          readonly enum: readonly ["refuse", "read-only"];
+          readonly description: "What the reactor does when this browser's store holds documents at protocol versions this build does not run. `refuse` fails the boot and names the versions; `read-only` boots and keeps those documents read-only.";
+          readonly default: "refuse";
+        };
       };
     };
     readonly pwa: {
@@ -911,5 +968,82 @@ declare const phConnectRuntimeConfigSchema: {
   };
 };
 //#endregion
-export { ConfigAdapter, ConfigLoader, ConfigShape, ConnectBuildEnv, ConnectEnv, ConnectRuntimeEnv, DEFAULT_CONNECT_CONFIG, DeepPartial, JsonConfigAdapter, JsonConfigAdapterOptions, LoadEnvOptions, type PHConnectPwa, type PHConnectPwaCacheStrategy, type PHConnectPwaFileHandler, type PHConnectPwaIcon, type PHConnectPwaManifest, type PHConnectPwaRuntimeCaching, type PHConnectPwaUrlPattern, PWA_FILE_HANDLER_ACTION, PWA_IDB_KEY, PWA_IDB_NAME, PWA_IDB_STORE, PWA_IDB_VERSION, PwaContribution, PwaWebManifest, ROOT_STORAGE_NAMESPACE, RuntimePowerhouseConfig, buildRuntimeConfig, connectEnvSchema, dedupeFileHandlers, dedupeIcons, deepMerge, getStorageNamespace, loadConnectEnv, loadRuntimeEnv, mergeManifest, mergePwaConfig, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, runtimeEnvSchema, setConnectEnv, toRegExpOrString, unionStrings, withInferredCategory };
+//#region connect/shared-deps.d.ts
+export type SharedDep = {
+  specifier: string;
+  package: string;
+};
+/**
+ * The dependency set Connect and loaded packages share via the import map.
+ * `@powerhousedao/connect` is deliberately absent: it is the Connect app
+ * itself (no importable exports), so there is nothing to share.
+ */
+export declare const SHARED_DEPS: readonly SharedDep[];
+export declare const SHARED_DEP_SPECIFIERS: readonly string[];
+/**
+ * The `@powerhousedao/shared` subpaths the production vendor bundles. The
+ * bare root is deliberately absent: its type barrel references node-only
+ * modules (`clis/`), which the current vite/rolldown cannot bundle for the
+ * browser — vendoring the root fails the build (a pre-existing latent
+ * issue). A package that imports the bare root is simply not shared; it
+ * bundles its own copy.
+ */
+export declare const SHARED_SUBPATHS: readonly string[];
+/**
+ * The specifiers a package build may safely externalize onto the host's
+ * import map — i.e. the ones the vendor actually publishes an entry for.
+ *
+ * `@powerhousedao/shared` is narrowed to SHARED_SUBPATHS rather than taken as
+ * a prefix: the bare root is never vendored (see SHARED_SUBPATHS), and
+ * neither are its other subpaths (`analytics`, `constants`, `clis`, ...).
+ * Externalizing those would leave a bare specifier in the package's output
+ * that nothing in the import map resolves, so the package would fail to load
+ * at runtime instead of simply bundling its own copy.
+ */
+export declare const EXTERNALIZABLE_SHARED_SPECIFIERS: readonly string[];
+/** Split a specifier into its package name and subpath ("" for a root). */
+export declare function parseDepSpec(spec: string): {
+  pkg: string;
+  sub: string;
+};
+/**
+ * Return the import/export specifiers in `source` that are a shared
+ * specifier (or a subpath of one), sorted. Heuristic: only statement
+ * positions are scanned (`from "x"`, `import "x"`, `import("x")`;
+ * `export … from "x"` is covered by the `from` pattern), so import-like
+ * text inside comments or strings can be reported too. That errs toward
+ * over-reporting, which is the safe direction for the advisory build
+ * warning.
+ */
+export declare function findSharedImports(source: string, specs?: readonly string[]): string[];
+/**
+ * Rewrite a package source for blob import in a worker context (import maps
+ * don't apply there): shared specifiers become their mapped URLs, and
+ * relative (`./`, `../`) specifiers become absolute against `sourceUrl`
+ * (a blob URL has no directory to resolve against). `#` subpath imports are
+ * deliberately left alone: they resolve via the package's own
+ * `package.json` "imports" field, which the rewrite cannot reproduce.
+ * Returns the input unchanged when nothing matched.
+ */
+export declare function rewritePackageSource(source: string, sourceUrl: string, imports: Record<string, string>): string;
+export type SharedDepMismatch = {
+  package: string;
+  required: string;
+  provided: string;
+};
+export type PackageDeps = {
+  dependencies?: Record<string, unknown>;
+  peerDependencies?: Record<string, unknown>;
+};
+/**
+ * Compare a package's declared ranges against the host's version table.
+ * `hostVersions` defines the checked set (only deps present in it are
+ * checked). `*`, non-semver protocols (workspace:, file:, git:, npm:, URLs)
+ * and unparseable ranges never mismatch.
+ */
+export declare function checkSharedDeps(pkgJson: PackageDeps, hostVersions: Record<string, string>): SharedDepMismatch[];
+export declare function formatSharedDepWarnings(mismatches: SharedDepMismatch[]): string[];
+//#endregion
+export { ConfigAdapter, ConfigLoader, ConfigShape, DeepPartial, JsonConfigAdapter, JsonConfigAdapterOptions, type PHConnectPwa, type PHConnectPwaCacheStrategy, type PHConnectPwaFileHandler, type PHConnectPwaIcon, type PHConnectPwaManifest, type PHConnectPwaRuntimeCaching, type PHConnectPwaUrlPattern, deepMerge, resolveSourceConnect };
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/connect/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../connect/env-config.ts","../../connect/pwa-config.ts","../../connect/pwa-manifest.ts","../../connect/runtime-config.ts","../../connect/schema-fragments.ts"],"mappings":";;;;;;;;;cAoBM,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;;;;;cA2HP,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAOhB,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKjB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,KACjC,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,gBAAA;AAAA,KACnC,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA;;;;UASvB,cAAA;;;;EAIf,UAAA,GAAa,MAAA;;;;EAIb,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;iBAkEI,cAAA,CAAe,OAAA,GAAS,cAAA,GAAsB,UAAA;;;;;;;;;iBAkB9C,cAAA,CACd,OAAA,GAAS,cAAA,GACR,iBAAA;;;;;;;;;;;;;;;iBAoBa,aAAA,CAAc,MAAA,EAAQ,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;iBA4C9B,iBAAA,CAAkB,QAAA;;;;;;cA8BrB,sBAAA;;;;;;;;;;;;;;;;;;;;;;;iBAwBG,mBAAA,CAAoB,QAAA;;;;KCrVxB,eAAA;0EAEV,MAAA;EACA,MAAA,EAAQ,YAAA;AAAA;AAAA,KA6BL,QAAA;EACH,GAAA;EACA,KAAA;EACA,OAAA;AAAA;;iBAyBc,WAAA,WAAsB,QAAA,CAAA,CAAU,KAAA,EAAO,CAAA,KAAM,CAAA;;;;;;;;;iBA4B7C,kBAAA,kBAAA,CAAqC,QAAA,EAAU,CAAA,KAAM,CAAA;;;;;;iBASrD,oBAAA,CACd,MAAA,EAAQ,YAAA,EACR,QAAA,YACC,YAAA;;iBASa,YAAA,CACd,IAAA,wBACA,KAAA;;;;;;;;;;;;;;;iBA2Gc,cAAA,CACd,oBAAA,EAAsB,eAAA,IACtB,aAAA,GAAgB,YAAA,EAChB,MAAA,IAAS,OAAA,oBACR,YAAA;;;iBA8Ca,gBAAA,CACd,OAAA,EAAS,sBAAA,YACC,MAAA;;;;;;;;ADnTY;;;cE8BX,uBAAA;AAAA,cAQA,YAAA;AAAA,cACA,aAAA;AAAA,cACA,WAAA;AAAA,cACA,eAAA;;;;UAKI,cAAA;EACf,KAAA,GAAQ,gBAAA;EACR,aAAA,IAAiB,uBAAA;IAA4B,MAAA;EAAA;EAC7C,UAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;iBAsBa,aAAA,CACd,IAAA,EAAM,cAAA,EACN,QAAA,EAAU,oBAAA,cACV,IAAA;EACE,YAAA;EACA,gBAAA;AAAA,IAED,cAAA;;;KCzES,uBAAA;EACV,aAAA;EACA,QAAA,EAAU,iBAAA;EACV,kBAAA;EACA,YAAA;IAAgB,IAAA;IAAc,OAAA;EAAA;EAC9B,OAAA,EAAS,sBAAA;AAAA;;;cAKE,sBAAA,EAAwB,sBAAA;AAAA,iBAqDrB,kBAAA,CACd,MAAA,EAAQ,IAAA,CAAK,gBAAA,kDACb,WAAA;EAAe,IAAA;EAAc,OAAA;AAAA,WAC5B,uBAAA;;;cCjEU,uBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;cA0FA,4BAAA;EAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../connect/dynamic-base.ts","../../connect/env-config.ts","../../connect/pwa-config.ts","../../connect/pwa-manifest.ts","../../connect/runtime-config.ts","../../connect/schema-fragments.ts","../../connect/shared-deps.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAYa;;;;;;cCQP,gBAAc,EAAA;;;;;;GA0BlB,EAAA,KAAA;;;;;;qBAiGW,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAES,EAAA,KAAA;;;;qBAKzB,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAgD,EAAA,KAAA;;;;YAKjE,kBAAkB,EAAE,aAAa;YACjC,oBAAoB,EAAE,aAAa;YACnC,aAAa,EAAE,aAAa;;;;iBASvB;;;;EAIf,aAAa;;;;EAIb,UAAU;;;;;;;;;;;wBAkEI,eAAe,UAAS,iBAAsB;;;;;;;;;wBAkB9C,eACd,UAAS,iBACR;;;;;;;;;;;;;;;wBAoBa,cAAc,QAAQ,QAAQ;;;;;;;;;;;;;;;;;wBA4C9B,kBAAkB;;;;;;qBA8BrB;;;;;;;;;;;;;;;;;;;;;;;wBAwBG,oBAAoB;;;;YCrVxB;;EAEV;EACA,QAAQ;;KA6BL;EACH;EACA;EACA;;;wBAyBc,YAAY,UAAU,UAAU,OAAO,MAAM;;;;;;;;;wBA4B7C,mBAAmB,kBAAkB,UAAU,MAAM;;;;;;wBASrD,qBACd,QAAQ,cACR,oBACC;;wBASa,aACd,4BACA;;;;;;;;;;;;;;;wBA2Gc,eACd,sBAAsB,mBACtB,gBAAgB,cAChB,UAAS,2BACR;;;wBA8Ca,iBACd,SAAS,kCACC;;;;;;;;;;;qBCrRC;qBAQA;qBACA;qBACA;qBACA;;;;iBAKI;EACf,QAAQ;EACR,iBAAiB;IAA4B;;EAC7C;GACC;;;;;;;;;;;;;;;;;;;;;wBAsBa,cACd,MAAM,gBACN,UAAU,kCACV;EACE;EACA;IAED;;;YCzES;EACV;EACA,UAAU;EACV;EACA;IAAgB;IAAc;;EAC9B,SAAS;;;;qBAKE,wBAAwB;wBA+DrB,mBACd,QAAQ,KAAK,kEACb;EAAe;EAAc;WAC5B;;;qBC3EU;WACX;WACA;WACA;WACA;aACE;eACE;eACA;;aAEF;eACE;eACA;;aAEF;eACE;eACA;eACA;;aAEF;eACE;eACA;;;;qBAsEO;WACX;WACA;WACA;WAEA;aACE;eACE;eACA;eACA;eACA;iBACE;mBACE;mBACA;;iBAGF;mBACE;mBACA;;;;aAKN;eACE;eACA;eACA;eACA;iBACE;mBACE;mBACA;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;;;;aAKN;eACE;eACA;eACA;eACA;iBACE;mBACE;mBACA;mBAEA;;;;aAIN;eACE;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;;;aAIN;eACE;eACA;eACA;eACA;iBACE;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;mBACA;qBACE;uBAEI;uBACA;uBACA;uBACA;yBACE;2BAAO;;yBACP;2BAAQ;;yBACR;2BAAQ;;;;uBAIV;uBACA;uBACA;uBACA;yBACE;2BACE;2BACA;;yBAGF;2BACE;2BACA;;yBAGF;2BAAQ;;yBACR;2BAAQ;;yBACR;2BACE;2BACA;;;;;;iBAQZ;mBACE;mBACA;mBACA;;iBAGF;mBACE;mBACA;mBACA;mBAEA;qBACE;uBA5NJ;;uBAGJ;;yBAEA;2BACE;2BACA;2BACA;;yBAEF;2BACE;2BACA;2BAEA;;yBAEF;2BACE;2BACA;2BAEA;;;;qBAyMM;;;;;;;;;;;;;;;;;;;;;;;;;;aAKR;eACE;eACA;eACA;eACA;iBACE;mBACE;mBACA;mBACA;;iBAEF;mBACE;mBACA;mBACA;;iBAEF;mBACE;mBACA;mBACA;;iBAEF;mBACE;mBACA;;iBAGF;mBACE;mBACA;;iBAGF;mBACE;mBACA;mBACA;mBAEA;qBACE;uBACE;uBACA;uBACA;uBACA;yBACE;2BACE;2BACA;;yBAGF;2BACE;2BACA;;;;qBAKN;uBACE;uBACA;uBACA;uBACA;yBACE;2BACE;2BACA;;yBAGF;2BACE;2BACA;;yBAEF;2BACE;2BACA;2BAEA;6BAAS;;;;;;;;;aAQvB;eACE;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBACA;;;;aAIN;eACE;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;;iBAGF;mBACE;mBACA;mBACA;;iBAEF;mBACE;mBACA;mBACA;;;;aAIN;eACE;eACA;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBAEA;;;;aAIN;eACE;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBACA;mBAEA;qBACE;uBACE;uBACA;uBAEA;;qBAEF;uBACE;uBACA;uBAEA;;qBAEF;uBACE;uBACA;uBAEA;;qBAEF;uBACE;uBACA;uBAEA;;;;iBAIN;mBACE;mBACA;mBACA;mBAEA;;iBAEF;mBACE;mBACA;mBACA;mBAEA;;;;aAIN;eACE;eACA;eACA;eAEA;iBACE;mBACE;mBACA;mBACA;mBACA;qBACE;uBAAQ;;qBACR;uBAAc;;qBACd;uBAAe;;qBACf;uBAAe;;qBACf;uBAAoB;;qBACpB;uBACE;uBACA;;qBAEF;uBAAa;;qBACb;uBAAS;;qBACT;uBACE;uBACA;uBAEA;yBA3ZN;;yBAEK;;2BAET;6BAAO;;2BACP;6BAAS;;2BACT;6BAAQ;;2BACR;6BAAW;;;;;qBAsZH;uBACE;uBACA;uBAEA;yBACE;yBACA;yBACA;yBACA;2BACE;6BACE;6BACA;6BAEA;+BACE;+BACA;iCAAS;iCAAgB;;;;2BAG7B;6BACE;6BACA;6BACA;;;;;;;;;;;;;;;;;;;;2BAEF;6BACE;6BACA;;;;;qBAKR;uBACE;uBACA;uBACA;uBACA;uBAEA;yBACE;2BACE;2BACA;;;;;;iBAWV;mBACE;mBACA;qBAAS;;mBACT;;iBAGF;mBACE;mBACA;qBAAS;;mBACT;;iBAGF;mBACE;mBACA;;iBAGF;mBACE;mBACA;mBAEA;qBACE;qBACA;qBACA;qBACA;uBACE;yBA1fV;;2BAEE;;2BAEA;2BACA;2BACA;2BACA;6BACE;+BAAU;+BAAgB;;6BAC1B;+BAAS;+BAAgB;;;;;uBAkfnB;yBACE;yBACA;;uBAQF;yBACE;yBACA;;uBAEF;yBACE;yBACA;yBACA;2BACE;6BAAa;;2BACb;6BACE;6BACA;;2BAGF;6BACE;6BACA;6BACA;+BACE;iCAAc;;+BACd;iCAAiB;;;;2BAGrB;6BACE;6BACA;6BACA;+BACE;iCAAY;iCAAe;mCAAS;;;+BACpC;iCACE;iCACA;mCAAwB;;;;;;;;;;iBASxC;mBACE;mBACA;mBAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;YClnBE;EAAc;EAAmB;;;;;;;qBAOhC,sBAAsB;qBA2BtB;;;;;;;;;qBAYA;;;;;;;;;;;;qBAqBA;;wBAQG,aAAa;EAAiB;EAAa;;;;;;;;;;;wBAwB3C,kBACd,gBACA;;;;;;;;;;wBA0Bc,qBACd,gBACA,mBACA,SAAS;YAkCC;EACV;EACA;EACA;;YAGU;EACV,eAAe;EACf,mBAAmB;;;;;;;;wBASL,gBACd,SAAS,aACT,cAAc,yBACb;wBAkBa,wBACd,YAAY"}