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

package/dist/connect/index.js

@@ -1,4 +1,4 @@
-import { i as buildRuntimeConfig, n as deepMerge, r as DEFAULT_CONNECT_CONFIG, t as ConfigLoader } from "../config-loader-19K8n4DO.js";
+import { i as buildRuntimeConfig, n as deepMerge, r as DEFAULT_CONNECT_CONFIG, t as ConfigLoader } from "../config-loader-B845Hidf.js";
 import { JsonConfigAdapter } from "./json-adapter.js";
 import { z } from "zod";
 //#region connect/env-config.ts
@@ -210,6 +210,225 @@ function getStorageNamespace(basePath) {
 	return `${ROOT_STORAGE_NAMESPACE}--${normalized.slice(1, -1).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "default"}`;
 }
 //#endregion
+//#region connect/pwa-config.ts
+const MANIFEST_SCALAR_KEYS = [
+	"name",
+	"short_name",
+	"description",
+	"theme_color",
+	"background_color",
+	"display",
+	"start_url",
+	"scope",
+	"launch_handler"
+];
+const ADDITIVE_MANIFEST_KEYS = new Set([
+	"icons",
+	"file_handlers",
+	"categories"
+]);
+function iconKey(icon) {
+	const purpose = typeof icon.purpose === "string" ? icon.purpose : icon.purpose?.join(",") ?? "";
+	return `${icon.src}|${icon.sizes ?? ""}|${purpose}`;
+}
+/** Concatenate, keeping the first occurrence per `key`. */
+function dedupeBy(items, key) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const item of items) {
+		const k = key(item);
+		if (seen.has(k)) continue;
+		seen.add(k);
+		result.push(item);
+	}
+	return result;
+}
+/** Concatenate icons, keeping the first occurrence of each (src,sizes,purpose). */
+function dedupeIcons(icons) {
+	return dedupeBy(icons, iconKey);
+}
+/** `JSON.stringify` with object keys sorted recursively, so two structurally
+* equal values always serialise identically (accept-map key order etc.). */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/**
+* Concatenate file handlers, keeping the first occurrence of each entry.
+* Deduped on the WHOLE entry (canonical JSON) rather than any single field:
+* every handler shares Connect's fixed action, and two handlers accepting
+* different file types are both real contributions — only the exact same
+* fragment arriving via two layers is a duplicate. Structural, so it also
+* works on the vite-plugin-pwa handler shape in builder-tools.
+*/
+function dedupeFileHandlers(handlers) {
+	return dedupeBy(handlers, stableStringify);
+}
+/** 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. */
+function withInferredCategory(config, category) {
+	if (typeof category !== "string" || !category) return config;
+	return {
+		...config,
+		manifest: {
+			...config.manifest,
+			categories: [category]
+		}
+	};
+}
+/** Order-preserving string union (used for the precache glob lists). */
+function unionStrings(base, extra) {
+	const result = [...base ?? []];
+	for (const item of extra) if (!result.includes(item)) result.push(item);
+	return result;
+}
+function patternKey(pattern) {
+	return typeof pattern === "string" ? `s:${pattern}` : `r:${pattern.source}:${pattern.flags ?? ""}`;
+}
+function unionPatterns(base, extra) {
+	const result = [...base ?? []];
+	const seen = new Set(result.map(patternKey));
+	for (const pattern of extra) {
+		const key = patternKey(pattern);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(pattern);
+	}
+	return result;
+}
+/** Merge one fragment into `target` in place, applying the per-field
+* strategies (manifest scalars deep-merge and win; icons/file_handlers/globs/
+* rules/denylist are additive; size ceiling takes the max). */
+function mergeInto(target, config) {
+	if (config.manifest) {
+		const { icons, file_handlers, categories, ...scalars } = config.manifest;
+		if (Object.keys(scalars).length > 0) target.manifest = deepMerge(target.manifest ?? {}, scalars);
+		if (icons?.length) target.manifest = {
+			...target.manifest ?? {},
+			icons: dedupeIcons([...target.manifest?.icons ?? [], ...icons])
+		};
+		if (file_handlers?.length) target.manifest = {
+			...target.manifest ?? {},
+			file_handlers: dedupeFileHandlers([...target.manifest?.file_handlers ?? [], ...file_handlers])
+		};
+		if (categories?.length) target.manifest = {
+			...target.manifest ?? {},
+			categories: unionStrings(target.manifest?.categories, categories)
+		};
+	}
+	if (config.globPatterns?.length) target.globPatterns = unionStrings(target.globPatterns, config.globPatterns);
+	if (config.globIgnores?.length) target.globIgnores = unionStrings(target.globIgnores, config.globIgnores);
+	if (config.runtimeCaching?.length) target.runtimeCaching = [...target.runtimeCaching ?? [], ...config.runtimeCaching];
+	if (config.navigateFallbackDenylist?.length) target.navigateFallbackDenylist = unionPatterns(target.navigateFallbackDenylist, config.navigateFallbackDenylist);
+	if (typeof config.maximumFileSizeToCacheInBytes === "number") target.maximumFileSizeToCacheInBytes = Math.max(target.maximumFileSizeToCacheInBytes ?? 0, config.maximumFileSizeToCacheInBytes);
+}
+/**
+* Fold the build-time-known package PWA fragments and the project's
+* `connect.pwa` block into one effective fragment. Precedence is
+* `packageContributions (in order) < projectConfig` — the project config wins
+* scalar fields, while arrays (`icons`, globs, `runtimeCaching`,
+* `navigateFallbackDenylist`) are additive across every layer and the size
+* ceiling takes the max.
+*
+* `onWarn` fires when two or more PACKAGES set the same manifest scalar to
+* different values and the project config doesn't settle it — the winner is
+* otherwise decided silently by package load order. The operator resolves it
+* by setting that field in `connect.pwa`, which both wins and silences the
+* warning.
+*/
+function mergePwaConfig(packageContributions, projectConfig, onWarn = () => {}) {
+	const merged = {};
+	const packageScalarSetters = {};
+	for (const { source, config } of packageContributions) {
+		mergeInto(merged, config);
+		for (const [key, value] of Object.entries(config.manifest ?? {})) {
+			if (ADDITIVE_MANIFEST_KEYS.has(key)) continue;
+			(packageScalarSetters[key] ??= []).push({
+				source,
+				value
+			});
+		}
+	}
+	if (projectConfig) mergeInto(merged, projectConfig);
+	const projectManifest = projectConfig?.manifest ?? {};
+	for (const key of MANIFEST_SCALAR_KEYS) {
+		const setters = packageScalarSetters[key];
+		const projectSettles = projectManifest[key] !== void 0;
+		if (!setters || setters.length < 2 || projectSettles) continue;
+		if (new Set(setters.map((s) => stableStringify(s.value))).size < 2) continue;
+		const sources = setters.map((s) => s.source);
+		onWarn(`PWA config: manifest.${key} set by multiple packages (${sources.join(", ")}); '${sources[sources.length - 1]}' wins by load order. Set connect.pwa.manifest.${key} in the project config to make the winner explicit.`);
+	}
+	return merged;
+}
+/** A serialisable URL pattern as Workbox consumes it: strings pass through
+* verbatim, `{ source, flags }` is rebuilt into a RegExp. */
+function toRegExpOrString(pattern) {
+	return typeof pattern === "string" ? pattern : new RegExp(pattern.source, pattern.flags);
+}
+//#endregion
+//#region connect/pwa-manifest.ts
+/**
+* The one route launched files open at, shared by the built-in handler and
+* injected into every contributed one. Not configurable: consuming launched
+* files takes runtime code that lives in Connect itself, and a relative "."
+* resolves against the manifest URL so it tracks any deploy base (the
+* webmanifest is served dynamically and never rewritten by the dynamic-base
+* plugin) — same trick as the base start_url/scope.
+*/
+const PWA_FILE_HANDLER_ACTION = ".";
+const PWA_IDB_NAME = "ph-pwa";
+const PWA_IDB_STORE = "fragments";
+const PWA_IDB_KEY = "merged";
+const PWA_IDB_VERSION = 1;
+/**
+* Lay a `PHConnectPwaManifest` fragment over a base web-manifest object.
+*
+* - **scalars** (name, theme_color, launch_handler, …): governed by
+*   `scalarPolicy`. `"fragment-wins"` lets the fragment overwrite the base;
+*   `"base-wins"` keeps the base and only fills fields it left unset. Keys
+*   listed in `protectedScalars` always behave as base-wins even under a
+*   fragment-wins policy — used at runtime to fragment-win cosmetic scalars
+*   while still protecting navigation-critical ones (`start_url`/`scope`) from
+*   an untrusted dynamically-installed package.
+* - **arrays** (icons, file_handlers): always additive, base entries first,
+*   de-duplicated — so a package can extend but never displace a built-in
+*   (Chromium is first-registered-wins per file extension, so `.phd`/`.phdm`
+*   stay Connect's).
+* - **categories**: order-preserving string union (derived from the manifest
+*   `category` field, not authored under `pwa`).
+*
+* The Connect-owned file-handler action is injected idempotently.
+*/
+function mergeManifest(base, fragment, opts) {
+	const scalarPolicy = opts?.scalarPolicy ?? "base-wins";
+	const protectedScalars = opts?.protectedScalars ?? [];
+	const result = { ...base };
+	const { icons, file_handlers, categories, ...scalars } = fragment ?? {};
+	const takeScalar = (key) => {
+		return (protectedScalars.includes(key) ? "base-wins" : scalarPolicy) === "fragment-wins" || result[key] === void 0;
+	};
+	for (const [key, value] of Object.entries(scalars)) if (takeScalar(key)) result[key] = value;
+	if (icons?.length) result.icons = dedupeIcons([...result.icons ?? [], ...icons]);
+	if (file_handlers?.length) {
+		const injected = file_handlers.map((handler) => ({
+			...handler,
+			action: "."
+		}));
+		result.file_handlers = dedupeFileHandlers([...result.file_handlers ?? [], ...injected]);
+	}
+	if (categories?.length) result.categories = unionStrings(result.categories, categories);
+	if (result.file_handlers?.length) result.file_handlers = result.file_handlers.map((handler) => ({
+		...handler,
+		action: "."
+	}));
+	return result;
+}
+//#endregion
 //#region connect/schema-fragments.ts
 const powerhousePackageSchema = {
 	type: "object",
@@ -262,6 +481,35 @@ const driveSectionSchema = {
 		}
 	}
 };
+const pwaUrlPatternSchema = {
+	description: "URL match. A string is matched verbatim by Workbox; { source, flags } is rebuilt into a RegExp at build time.",
+	oneOf: [{ type: "string" }, {
+		type: "object",
+		additionalProperties: false,
+		required: ["source"],
+		properties: {
+			source: {
+				type: "string",
+				description: "RegExp source."
+			},
+			flags: {
+				type: "string",
+				description: "RegExp flags (e.g. 'i')."
+			}
+		}
+	}]
+};
+const pwaIconSchema = {
+	type: "object",
+	additionalProperties: false,
+	required: ["src"],
+	properties: {
+		src: { type: "string" },
+		sizes: { type: "string" },
+		type: { type: "string" },
+		purpose: { type: "string" }
+	}
+};
 const phConnectRuntimeConfigSchema = {
 	type: "object",
 	additionalProperties: false,
@@ -315,6 +563,16 @@ const phConnectRuntimeConfigSchema = {
 				}
 			}
 		},
+		ai: {
+			type: "object",
+			additionalProperties: false,
+			description: "AI assistant (chat) behaviour.",
+			properties: { assistantEnabled: {
+				type: "boolean",
+				description: "When true, Connect mounts the in-browser AI assistant (bottom-right chat FAB that talks to a user-configured OpenAI-compatible endpoint and acts on the reactor). Disabled by default.",
+				default: false
+			} }
+		},
 		packages: {
 			type: "object",
 			additionalProperties: false,
@@ -344,9 +602,9 @@ const phConnectRuntimeConfigSchema = {
 				},
 				defaultDrives: {
 					type: "array",
-					description: "Drives the SPA auto-connects to on first load. Each must specify a URL; name and icon are optional overrides.",
+					description: "Drives the SPA auto-connects to on first load. Each entry is either a remote drive (a URL, with optional name/icon overrides) or a local drive (created locally on first boot, with a stable id and optional name/icon/app).",
 					default: [],
-					items: {
+					items: { oneOf: [{
 						type: "object",
 						additionalProperties: false,
 						required: ["url"],
@@ -355,7 +613,27 @@ const phConnectRuntimeConfigSchema = {
 							name: { type: ["string", "null"] },
 							icon: { type: ["string", "null"] }
 						}
-					}
+					}, {
+						type: "object",
+						additionalProperties: false,
+						required: ["local", "id"],
+						properties: {
+							local: {
+								const: true,
+								description: "Discriminator: this entry is a local drive created on first boot."
+							},
+							id: {
+								type: "string",
+								description: "Stable drive id. The drive is created with this id on first boot and is not re-created on later boots."
+							},
+							name: { type: ["string", "null"] },
+							icon: { type: ["string", "null"] },
+							app: {
+								type: "string",
+								description: "Drive app (preferred editor) to open on the drive."
+							}
+						}
+					}] }
 				},
 				preserveStrategy: {
 					type: "string",
@@ -392,6 +670,56 @@ const phConnectRuntimeConfigSchema = {
 					type: "number",
 					description: "CAIP-2 chain reference within the network namespace.",
 					default: 1
+				},
+				namespace: {
+					type: "string",
+					description: "Renown localStorage namespace; share it across Connects to share login."
+				},
+				switchboardUrl: {
+					type: "string",
+					description: "Switchboard GraphQL URL. When set, Connect enables in-page (no-redirect) Renown sign-in; otherwise it falls back to the redirect flow via `url`."
+				},
+				adapters: {
+					type: "object",
+					additionalProperties: false,
+					description: "Per-adapter wallet config for in-page auth. Presence of an adapter key enables it; omit or leave empty for redirect-only behaviour.",
+					properties: {
+						rainbow: {
+							type: "object",
+							additionalProperties: false,
+							description: "wagmi + RainbowKit external-wallet adapter config.",
+							properties: {
+								walletConnectProjectId: {
+									type: "string",
+									description: "WalletConnect project id; required for this adapter to function."
+								},
+								infuraProjectId: {
+									type: "string",
+									description: "Optional Infura project id used to build RPC transports."
+								}
+							}
+						},
+						privy: {
+							type: "object",
+							additionalProperties: false,
+							description: "Privy embedded/social adapter config.",
+							properties: {
+								appId: {
+									type: "string",
+									description: "Privy application id; required for this adapter to function."
+								},
+								clientId: {
+									type: "string",
+									description: "Optional Privy client id."
+								},
+								methods: {
+									type: "array",
+									description: "Login methods this adapter offers; default per adapter when omitted.",
+									items: { type: "string" }
+								}
+							}
+						}
+					}
 				}
 			}
 		},
@@ -434,10 +762,208 @@ const phConnectRuntimeConfigSchema = {
 					default: false
 				}
 			}
+		},
+		reactor: {
+			type: "object",
+			additionalProperties: false,
+			description: "Settings for the reactor Connect runs in the browser, on the main thread or in the shared worker alike.",
+			properties: { featureFlags: {
+				type: "object",
+				additionalProperties: false,
+				description: "Enforcement flags. Each implies its predecessors, and the reactor refuses to boot on a set that names a later flag without an earlier one. These are consensus settings: a Connect syncing with a fleet must carry the same flags the fleet does, or the two reach different replay outcomes for the same history and diverge.",
+				properties: {
+					documentDecisions: {
+						type: "boolean",
+						description: "Decide writes from the document stream rather than the document meta cache, so a backdated deletion denies the operations that sort after it.",
+						default: false
+					},
+					authEnforcement: {
+						type: "boolean",
+						description: "Enforce the auth scope's policy at admission, replay, and read. Requires documentDecisions.",
+						default: false
+					},
+					authGroups: {
+						type: "boolean",
+						description: "Let `{ group }` principals match against the rosters of the group documents a policy names. Requires authEnforcement.",
+						default: false
+					},
+					authConditions: {
+						type: "boolean",
+						description: "Evaluate `where` and `match` conditions on grants. Requires authGroups. Do not enable on a fleet `preflight:auth` reports as crossing a reducer version.",
+						default: false
+					}
+				}
+			} }
+		},
+		pwa: {
+			type: "object",
+			additionalProperties: false,
+			description: "Progressive-web-app / service-worker overrides, layered on Connect's built-in PWA defaults at build time. Scalar fields deep-merge (this layer wins); the array members (icons, file_handlers, globs, runtimeCaching and denylist patterns) are additive; maximumFileSizeToCacheInBytes takes the max across contributors. (categories is not set here — it is derived from the manifest's category field.) Only applied when connect.app.offline is true.",
+			properties: {
+				manifest: {
+					type: "object",
+					additionalProperties: false,
+					description: "Web-app-manifest field overrides.",
+					properties: {
+						name: { type: "string" },
+						short_name: { type: "string" },
+						description: { type: "string" },
+						theme_color: { type: "string" },
+						background_color: { type: "string" },
+						display: {
+							type: "string",
+							enum: [
+								"fullscreen",
+								"standalone",
+								"minimal-ui",
+								"browser"
+							]
+						},
+						start_url: { type: "string" },
+						scope: { type: "string" },
+						icons: {
+							type: "array",
+							description: "Icons appended to the built-in set and de-duplicated by (src, sizes, purpose).",
+							items: pwaIconSchema
+						},
+						file_handlers: {
+							type: "array",
+							description: "File associations appended after Connect's built-in .phd/.phdm handler and de-duplicated on the whole entry. Entries only declare accepted types; there is no action field, because opening the files requires Connect's own runtime handling, so every handler opens at the app root.",
+							items: {
+								type: "object",
+								additionalProperties: false,
+								required: ["accept"],
+								properties: {
+									accept: {
+										type: "object",
+										description: "MIME type → file extensions. Each extension must start with '.'; browsers ignore entries without it.",
+										additionalProperties: {
+											type: "array",
+											items: {
+												type: "string",
+												pattern: "^\\."
+											}
+										}
+									},
+									icons: {
+										type: "array",
+										description: "OS-level file-type icons.",
+										items: pwaIconSchema
+									},
+									launch_type: {
+										type: "string",
+										enum: ["single-client", "multiple-clients"]
+									}
+								}
+							}
+						},
+						launch_handler: {
+							type: "object",
+							additionalProperties: false,
+							required: ["client_mode"],
+							description: "How the OS launches the app for handled files/links. Connect defaults to focus-existing.",
+							properties: { client_mode: {
+								type: "string",
+								enum: [
+									"auto",
+									"focus-existing",
+									"navigate-existing",
+									"navigate-new"
+								]
+							} }
+						}
+					}
+				},
+				globPatterns: {
+					type: "array",
+					items: { type: "string" },
+					description: "Extra Workbox precache globs, unioned with the built-ins."
+				},
+				globIgnores: {
+					type: "array",
+					items: { type: "string" },
+					description: "Extra precache ignore globs, unioned with the built-ins."
+				},
+				maximumFileSizeToCacheInBytes: {
+					type: "number",
+					description: "Raise the precache file-size ceiling. The max across all contributors wins, so no contributor can shrink another's limit."
+				},
+				runtimeCaching: {
+					type: "array",
+					description: "Runtime-caching rules appended after the built-in rules. Workbox is first-match-wins, so these cannot override a built-in rule matching the same URL.",
+					items: {
+						type: "object",
+						additionalProperties: false,
+						required: ["urlPattern", "handler"],
+						properties: {
+							urlPattern: pwaUrlPatternSchema,
+							handler: {
+								type: "string",
+								enum: [
+									"CacheFirst",
+									"CacheOnly",
+									"NetworkFirst",
+									"NetworkOnly",
+									"StaleWhileRevalidate"
+								]
+							},
+							method: {
+								type: "string",
+								enum: [
+									"GET",
+									"POST",
+									"PUT",
+									"DELETE",
+									"HEAD",
+									"PATCH"
+								]
+							},
+							options: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									cacheName: { type: "string" },
+									networkTimeoutSeconds: {
+										type: "number",
+										description: "Seconds a NetworkFirst rule waits for the network before falling back to the cache."
+									},
+									expiration: {
+										type: "object",
+										additionalProperties: false,
+										properties: {
+											maxEntries: { type: "number" },
+											maxAgeSeconds: { type: "number" }
+										}
+									},
+									cacheableResponse: {
+										type: "object",
+										additionalProperties: false,
+										properties: {
+											statuses: {
+												type: "array",
+												items: { type: "number" }
+											},
+											headers: {
+												type: "object",
+												additionalProperties: { type: "string" }
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				},
+				navigateFallbackDenylist: {
+					type: "array",
+					description: "Extra SPA navigate-fallback denylist patterns, unioned with the built-ins.",
+					items: pwaUrlPatternSchema
+				}
+			}
 		}
 	}
 };
 //#endregion
-export { ConfigLoader, DEFAULT_CONNECT_CONFIG, JsonConfigAdapter, ROOT_STORAGE_NAMESPACE, buildRuntimeConfig, connectEnvSchema, deepMerge, getStorageNamespace, loadConnectEnv, loadRuntimeEnv, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, runtimeEnvSchema, setConnectEnv };
+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 };
 
 //# sourceMappingURL=index.js.map