@powerhousedao/shared 6.2.3-dev.10 → 6.2.3-dev.12

package/dist/{config-loader-B845Hidf.js → config-loader-e4-qdVVI.js}

@@ -11,7 +11,8 @@ const DEFAULT_CONNECT_CONFIG = {
 		logLevel: "info",
 		basePath: "/",
 		offline: true,
-		studioMode: false
+		studioMode: false,
+		workflowsEnabled: false
 	},
 	ai: { assistantEnabled: false },
 	packages: {
@@ -144,4 +145,4 @@ var ConfigLoader = class {
 //#endregion
 export { buildRuntimeConfig as i, deepMerge as n, DEFAULT_CONNECT_CONFIG as r, ConfigLoader as t };
 
-//# sourceMappingURL=config-loader-B845Hidf.js.map
+//# sourceMappingURL=config-loader-e4-qdVVI.js.map

package/dist/config-loader-e4-qdVVI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader-e4-qdVVI.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    workflowsEnabled: 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  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  },\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 { PHConnectRuntimeConfig } 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 * 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;EACjB;CACD,KAAK;EACH,UAAU;EACV,UAAU;EACV,SAAS;EACT,YAAY;EACZ,kBAAkB;EACnB;CACD,IAAI,EACF,kBAAkB,OACnB;CACD,UAAU;EACR,iBAAiB;EACjB,YAAY;EACb;CACD,QAAQ;EACN,eAAe;EACf,eAAe,EAAE;EACjB,UAAU;GACR,QAAQ;IAAE,SAAS;IAAM,UAAU;IAAM,aAAa;IAAM;GAC5D,OAAO;IAAE,SAAS;IAAM,UAAU;IAAM,aAAa;IAAM;GAC5D;EACF;CACD,QAAQ;EACN,KAAK;EACL,WAAW;EACX,SAAS;EACV;CACD,QAAQ;EAIN,KAAK;EACL,KAAK;EACL,SAAS;EACV;CACD,UAAU;EACR,WAAW;EACX,eAAe;EAChB;CACD,SAAS,EACP,cAAc;EACZ,mBAAmB;EACnB,iBAAiB;EACjB,YAAY;EACZ,gBAAgB;EACjB,EACF;CACF;AAED,SAAgB,mBACd,QACA,aACyB;CACzB,MAAM,SAAkC;EACtC,eAAe;EACf,UAAU,OAAO,YAAY,EAAE;EAC/B,cAAc;EACd,SAAS,OAAO,WAAW,EAAE;EAC9B;AACD,KACE,OAAO,OAAO,uBAAuB,YACrC,OAAO,uBAAuB,GAE9B,QAAO,qBAAqB,OAAO;AAErC,QAAO;;;;;;;;;;;;ACvBT,SAAgB,UAAa,MAAS,OAA0B;AAC9D,KAAI,CAAC,cAAc,KAAK,IAAI,CAAC,cAAc,MAAM,CAC/C,QAAO;CAET,MAAM,SAAkC,EAAE,GAAG,MAAM;AACnD,MAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,MAAM,EAAE;AACrD,MAAI,eAAe,KAAA,EAAW;EAC9B,MAAM,YAAY,OAAO;AACzB,MAAI,cAAc,UAAU,IAAI,cAAc,WAAW,CACvD,QAAO,OAAO,UACZ,WACA,WACD;MAED,QAAO,OAAO;;AAGlB,QAAO;;;;;;;;;;;;;;AAeT,IAAa,eAAb,MAA0B;CACxB;CAEA,YACE,SACA,WAAoD,wBACpD;AAFiB,OAAA,UAAA;AACA,OAAA,WAAA;;;;CAKnB,MAAM,OAA6B;AACjC,MAAI,KAAK,MAAO,QAAO,KAAK;EAC5B,MAAM,MAAM,MAAM,KAAK,QAAQ,MAAM;EACrC,MAAM,MAAM,cAAc,IAAI,GAAG,MAAM,EAAE;EACzC,MAAM,aAAa,cAAc,IAAI,QAAQ,GAAG,IAAI,UAAU,EAAE;AAChE,OAAK,QAAQ;GACX,GAAG;GACH,SAAS,UACP,KAAK,UACL,WACD;GACF;AACD,SAAO,KAAK;;;;;;CAOd,YAAyB;AACvB,MAAI,CAAC,KAAK,MACR,OAAM,IAAI,MACR,iBAAiB,KAAK,QAAQ,OAAO,oCACtC;AAEH,SAAO,KAAK;;;CAId,aAAmB;AACjB,OAAK,QAAQ,KAAA;;;;;;;CAQf,MAAM,MAAM,OAAuD;EAEjE,MAAM,OAAO,UADG,MAAM,KAAK,MAAM,EACD,MAAM;AACtC,QAAM,KAAK,QAAQ,MAAM,KAAK;AAC9B,OAAK,QAAQ;AACb,SAAO"}

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

@@ -1,4 +1,4 @@
-import { D as PHConnectRuntimeConfig } from "../types-BIoOWpOT.js";
+import { D as PHConnectRuntimeConfig } from "../types-DX5QXaOU.js";
 
 //#region connect/config-loader.d.ts
 /** Recursive Partial. Arrays are leaves — `write({ packages: [...] })`

package/dist/connect/config-loader.js

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

package/dist/connect/index.d.ts

@@ -1,8 +1,23 @@
-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 { 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-DX5QXaOU.js";
 import { ConfigAdapter, ConfigLoader, ConfigShape, DeepPartial, deepMerge } 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.
+ */
+declare const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
+//#endregion
 //#region connect/env-config.d.ts
 /**
  * Build-time configuration schema
@@ -367,6 +382,11 @@ 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. Connect's counterpart to the reactor-side `workflows.enabled` / PH_WORKFLOWS_ENABLED; independent of studioMode. False by default.";
+          readonly default: false;
+        };
       };
     };
     readonly ai: {
@@ -911,5 +931,81 @@ 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
+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.
+ */
+declare const SHARED_DEPS: readonly SharedDep[];
+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.
+ */
+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.
+ */
+declare const EXTERNALIZABLE_SHARED_SPECIFIERS: readonly string[];
+/** Split a specifier into its package name and subpath ("" for a root). */
+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.
+ */
+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.
+ */
+declare function rewritePackageSource(source: string, sourceUrl: string, imports: Record<string, string>): string;
+type SharedDepMismatch = {
+  package: string;
+  required: string;
+  provided: string;
+};
+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.
+ */
+declare function checkSharedDeps(pkgJson: PackageDeps, hostVersions: Record<string, string>): SharedDepMismatch[];
+declare function formatSharedDepWarnings(mismatches: SharedDepMismatch[]): string[];
+//#endregion
+export { ConfigAdapter, ConfigLoader, ConfigShape, ConnectBuildEnv, ConnectEnv, ConnectRuntimeEnv, DEFAULT_CONNECT_CONFIG, DYNAMIC_BASE_PLACEHOLDER, DeepPartial, EXTERNALIZABLE_SHARED_SPECIFIERS, 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, PackageDeps, PwaContribution, PwaWebManifest, ROOT_STORAGE_NAMESPACE, RuntimePowerhouseConfig, SHARED_DEPS, SHARED_DEP_SPECIFIERS, SHARED_SUBPATHS, SharedDep, SharedDepMismatch, buildRuntimeConfig, checkSharedDeps, connectEnvSchema, dedupeFileHandlers, dedupeIcons, deepMerge, findSharedImports, formatSharedDepWarnings, getStorageNamespace, loadConnectEnv, loadRuntimeEnv, mergeManifest, mergePwaConfig, normalizeBasePath, parseDepSpec, phConnectRuntimeConfigSchema, powerhousePackageSchema, rewritePackageSource, runtimeEnvSchema, setConnectEnv, toRegExpOrString, unionStrings, withInferredCategory };
 //# 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":"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"}

package/dist/connect/index.js

@@ -1,6 +1,22 @@
-import { i as buildRuntimeConfig, n as deepMerge, r as DEFAULT_CONNECT_CONFIG, t as ConfigLoader } from "../config-loader-B845Hidf.js";
+import { i as buildRuntimeConfig, n as deepMerge, r as DEFAULT_CONNECT_CONFIG, t as ConfigLoader } from "../config-loader-e4-qdVVI.js";
 import { JsonConfigAdapter } from "./json-adapter.js";
 import { z } from "zod";
+import { satisfies, validRange } from "semver";
+//#region connect/dynamic-base.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.
+*/
+const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
+//#endregion
 //#region connect/env-config.ts
 /**
 * Coerces string values to boolean.
@@ -560,6 +576,11 @@ const phConnectRuntimeConfigSchema = {
 					type: "boolean",
 					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.",
 					default: false
+				},
+				workflowsEnabled: {
+					type: "boolean",
+					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. Connect's counterpart to the reactor-side `workflows.enabled` / PH_WORKFLOWS_ENABLED; independent of studioMode. False by default.",
+					default: false
 				}
 			}
 		},
@@ -964,6 +985,169 @@ const phConnectRuntimeConfigSchema = {
 	}
 };
 //#endregion
-export { ConfigLoader, DEFAULT_CONNECT_CONFIG, JsonConfigAdapter, PWA_FILE_HANDLER_ACTION, PWA_IDB_KEY, PWA_IDB_NAME, PWA_IDB_STORE, PWA_IDB_VERSION, ROOT_STORAGE_NAMESPACE, buildRuntimeConfig, connectEnvSchema, dedupeFileHandlers, dedupeIcons, deepMerge, getStorageNamespace, loadConnectEnv, loadRuntimeEnv, mergeManifest, mergePwaConfig, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, runtimeEnvSchema, setConnectEnv, toRegExpOrString, unionStrings, withInferredCategory };
+//#region connect/shared-deps.ts
+/**
+* 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.
+*/
+const SHARED_DEPS = [
+	{
+		specifier: "document-model",
+		package: "document-model"
+	},
+	{
+		specifier: "@powerhousedao/document-engineering",
+		package: "@powerhousedao/document-engineering"
+	},
+	{
+		specifier: "@powerhousedao/shared",
+		package: "@powerhousedao/shared"
+	},
+	{
+		specifier: "@powerhousedao/shared/registry/urls",
+		package: "@powerhousedao/shared"
+	},
+	{
+		specifier: "@powerhousedao/design-system/connect",
+		package: "@powerhousedao/design-system"
+	},
+	{
+		specifier: "@powerhousedao/reactor-browser",
+		package: "@powerhousedao/reactor-browser"
+	},
+	{
+		specifier: "zod",
+		package: "zod"
+	}
+];
+const SHARED_DEP_SPECIFIERS = SHARED_DEPS.map((d) => d.specifier);
+/**
+* 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.
+*/
+const SHARED_SUBPATHS = [
+	"connect",
+	"document-model",
+	"processors",
+	"document-drive",
+	"registry",
+	"registry/urls",
+	"registry/manifest-slim"
+];
+/**
+* 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.
+*/
+const EXTERNALIZABLE_SHARED_SPECIFIERS = [...new Set([...SHARED_DEP_SPECIFIERS.filter((s) => s !== "@powerhousedao/shared"), ...SHARED_SUBPATHS.map((s) => `@powerhousedao/shared/${s}`)])];
+/** Split a specifier into its package name and subpath ("" for a root). */
+function parseDepSpec(spec) {
+	if (spec.startsWith("@")) {
+		const parts = spec.split("/");
+		return {
+			pkg: parts.slice(0, 2).join("/"),
+			sub: parts.slice(2).join("/")
+		};
+	}
+	const i = spec.indexOf("/");
+	return i === -1 ? {
+		pkg: spec,
+		sub: ""
+	} : {
+		pkg: spec.slice(0, i),
+		sub: spec.slice(i + 1)
+	};
+}
+function isSharedSpecifier(spec, specs) {
+	return specs.some((s) => spec === s || spec.startsWith(s + "/"));
+}
+/**
+* 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.
+*/
+function findSharedImports(source, specs = SHARED_DEP_SPECIFIERS) {
+	const found = /* @__PURE__ */ new Set();
+	for (const re of [
+		/\bfrom\s+["']([^"'\\]+)["']/g,
+		/\bimport\s+["']([^"'\\]+)["']/g,
+		/\bimport\s*\(\s*["']([^"'\\]+)["']\s*\)/g
+	]) for (const m of source.matchAll(re)) {
+		const spec = m[1];
+		if (isSharedSpecifier(spec, specs)) found.add(spec);
+	}
+	return [...found].sort();
+}
+/**
+* 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.
+*/
+function rewritePackageSource(source, sourceUrl, imports) {
+	if (!Object.keys(imports).length) return source;
+	const base = new URL(sourceUrl);
+	const map = (spec) => {
+		const mapped = imports[spec];
+		if (mapped) return mapped;
+		if (spec.startsWith("./") || spec.startsWith("../")) return new URL(spec, base).href;
+		return null;
+	};
+	let out = source;
+	for (const re of [
+		/\bfrom\s+(["'])([^"'\\]+)\1/g,
+		/\bimport\s+(["'])([^"'\\]+)\1/g,
+		/\bimport\s*\(\s*(["'])([^"'\\]+)\1\s*\)/g
+	]) out = out.replace(re, (match, quote, spec) => {
+		const mapped = map(spec);
+		return mapped ? match.replace(`${quote}${spec}${quote}`, `${quote}${mapped}${quote}`) : match;
+	});
+	return out;
+}
+/**
+* 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.
+*/
+function checkSharedDeps(pkgJson, hostVersions) {
+	const out = [];
+	const entries = [...Object.entries(pkgJson.dependencies ?? {}), ...Object.entries(pkgJson.peerDependencies ?? {})];
+	for (const [dep, range] of entries) {
+		const provided = hostVersions[dep];
+		if (provided === void 0 || typeof range !== "string") continue;
+		if (range === "*" || /^[a-z]+:/i.test(range)) continue;
+		if (!validRange(range)) continue;
+		if (!satisfies(provided, range, { includePrerelease: true })) out.push({
+			package: dep,
+			required: range,
+			provided
+		});
+	}
+	return out;
+}
+function formatSharedDepWarnings(mismatches) {
+	return mismatches.map((m) => `${m.package}: requires ${m.required}, Connect provides ${m.provided}`);
+}
+//#endregion
+export { ConfigLoader, DEFAULT_CONNECT_CONFIG, DYNAMIC_BASE_PLACEHOLDER, EXTERNALIZABLE_SHARED_SPECIFIERS, JsonConfigAdapter, PWA_FILE_HANDLER_ACTION, PWA_IDB_KEY, PWA_IDB_NAME, PWA_IDB_STORE, PWA_IDB_VERSION, ROOT_STORAGE_NAMESPACE, SHARED_DEPS, SHARED_DEP_SPECIFIERS, SHARED_SUBPATHS, buildRuntimeConfig, checkSharedDeps, connectEnvSchema, dedupeFileHandlers, dedupeIcons, deepMerge, findSharedImports, formatSharedDepWarnings, getStorageNamespace, loadConnectEnv, loadRuntimeEnv, mergeManifest, mergePwaConfig, normalizeBasePath, parseDepSpec, phConnectRuntimeConfigSchema, powerhousePackageSchema, rewritePackageSource, runtimeEnvSchema, setConnectEnv, toRegExpOrString, unionStrings, withInferredCategory };
 
 //# sourceMappingURL=index.js.map