@corensystem/coren-ui 1.0.0-next.20260924.75108.887a9c2

package/dist/pages/wc3-product-install-dialog.mjs

@@ -0,0 +1,808 @@
+import { Badge } from "../badge.mjs";
+import { Button } from "../button.mjs";
+import { Card, CardContent, CardHeader, CardTitle } from "../card.mjs";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "../dialog.mjs";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../select.mjs";
+import { Label } from "../label.mjs";
+import { Input } from "../input.mjs";
+import { Banner } from "../banner.mjs";
+import { MetricCard } from "../metric-card.mjs";
+import { PropertyList, PropertyRow } from "../property-list.mjs";
+import { toast } from "../sonner.mjs";
+import { Stepper, StepperIndicator, StepperItem, StepperLabel, StepperList, StepperSeparator } from "../stepper.mjs";
+import { WC3_ACTION_TYPES, WC3_LINK_TYPES, WC3_OBJECT_TYPES } from "./wc3-ontology-data.mjs";
+import { Mono } from "./wc3-lineage-shared.mjs";
+import { WC3_PRODUCT_ENVS, productOutputSummary } from "./wc3-product-data.mjs";
+import { DEFAULT_RELEASE_EVIDENCE, LIVE_ACTION_API_NAMES, LIVE_LINK_API_NAMES, LIVE_OBJECT_TYPE_BY_API, camelApiName, gateOkSentence, isInstalledIn, personaRoles, roleGate } from "./wc3-product-shared.mjs";
+import { cn } from "@corensystem/coren-utils";
+import { Check, Link2, Play, Zap } from "lucide-react";
+import * as React from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/pages/wc3-product-install-dialog.tsx
+/** The prototype's nowStr() — a wall-clock label, not an ISO stamp. */
+const nowStr = () => (/* @__PURE__ */ new Date()).toLocaleTimeString();
+/** Which of the manifest's three install gates a target environment reads. */
+function envGateKey(env) {
+	return WC3_PRODUCT_ENVS.find((e) => e.env === env)?.gateKey ?? "installProdRoles";
+}
+/**
+* Previews what installing `p` into `env` would do, against the LIVE ontology fixture and the LIVE
+* install array.
+*
+* A name that is free at check time is RESERVED, so a manifest that declares the same name twice
+* collides with itself on the second occurrence — the prototype's behaviour, and the reason the
+* reserved sets are seeded from the shared module's live indexes rather than queried per name.
+*
+* A collision is never fatal and never overwrites: it is skipped at apply time and recorded on the
+* install record's `skipped` bucket.
+*/
+function computeInstallPlan(p, env, persona, installs) {
+	const gateKey = envGateKey(env);
+	const perm = roleGate(p, gateKey, persona);
+	const o = p.outputs;
+	const ont = o.ontology;
+	const otApis = new Set(LIVE_OBJECT_TYPE_BY_API.keys());
+	const objAdd = [];
+	const objCollide = [];
+	for (const name of o.ontologyObjectTypes) {
+		const apiName = camelApiName(name);
+		if (otApis.has(apiName)) {
+			const owner = LIVE_OBJECT_TYPE_BY_API.get(apiName);
+			objCollide.push({
+				name,
+				apiName,
+				ownerId: owner?.id ?? null,
+				owner: owner?.displayName ?? apiName,
+				ownerProduct: owner?.installedBy?.productKey ?? null
+			});
+		} else {
+			objAdd.push({
+				name,
+				apiName
+			});
+			otApis.add(apiName);
+		}
+	}
+	const ltApis = new Set(LIVE_LINK_API_NAMES);
+	const ltAdd = [];
+	const ltCollide = [];
+	for (const name of o.ontologyLinkTypes) {
+		const apiName = camelApiName(name);
+		if (ltApis.has(apiName)) ltCollide.push({
+			name,
+			apiName
+		});
+		else {
+			ltAdd.push({
+				name,
+				apiName
+			});
+			ltApis.add(apiName);
+		}
+	}
+	const atApis = new Set(LIVE_ACTION_API_NAMES);
+	const actAdd = [];
+	const actCollide = [];
+	for (const name of ont.actionTypes) {
+		const apiName = camelApiName(name);
+		if (atApis.has(apiName)) actCollide.push({
+			name,
+			apiName
+		});
+		else {
+			actAdd.push({
+				name,
+				apiName
+			});
+			atApis.add(apiName);
+		}
+	}
+	const deps = p.dependencies.map((d) => ({
+		...d,
+		satisfied: isInstalledIn(installs, d.productKey)
+	}));
+	const linked = p.linkedProducts.map((l) => ({
+		...l,
+		satisfied: isInstalledIn(installs, l.productKey)
+	}));
+	const blockers = [];
+	if (!perm.ok) blockers.push({
+		code: "permission",
+		text: perm.reason
+	});
+	for (const d of deps) if (d.required && !d.satisfied) blockers.push({
+		code: "dependency",
+		text: `Blocked: required dependency ${d.productKey} ${d.versionRange} is not installed in this workspace.`
+	});
+	for (const l of linked) if (!l.optional && !l.satisfied) blockers.push({
+		code: "linked",
+		text: `Blocked: non-optional linked product ${l.productKey} ${l.version} (role: ${l.role}) is not installed.`
+	});
+	if (isInstalledIn(installs, p.productKey)) blockers.push({
+		code: "installed",
+		text: `Blocked: ${p.productKey} already has an applied install in this workspace. Roll it back or uninstall it first.`
+	});
+	const rd = p.readiness;
+	if (rd && rd.blockedReasons.length > 0 && env === "Prod") for (const reason of rd.blockedReasons) blockers.push({
+		code: "readiness",
+		text: `Blocked by declared readiness (${rd.classification || "readiness"}): ${reason}`
+	});
+	if (objAdd.length === 0 && ltAdd.length === 0 && actAdd.length === 0 && blockers.length === 0) blockers.push({
+		code: "noop",
+		text: "Blocked: this plan adds nothing — every ontology primitive the manifest declares already exists under the same API name."
+	});
+	const applySteps = [];
+	applySteps.push(`Resolve product graph — ${1 + linked.length} node(s), ${deps.length} declared dependenc(ies)`);
+	applySteps.push(`Verify ${gateKey} against the acting principal`);
+	if (objAdd.length) applySteps.push(`Create ${objAdd.length} ontology object type(s) with primary + title keys`);
+	if (ltAdd.length) applySteps.push(`Create ${ltAdd.length} ontology link type(s), endpoints resolved from the manifest names`);
+	if (actAdd.length) applySteps.push(`Register ${actAdd.length} ontology action type(s)`);
+	applySteps.push(`Grant ${o.osdkScopes.length} OSDK scope(s) and mount ${o.appRoutes.length} app route(s)`);
+	applySteps.push("Record metadata / lineage / lakehouse provenance against install id");
+	applySteps.push("Write the changeset entry (undoable) and push a time-machine snapshot");
+	const rollbackSteps = applySteps.slice().reverse().map((s) => s.replace(/^Create /, "Drop ").replace(/^Register /, "Deregister ").replace(/^Grant /, "Revoke "));
+	return {
+		productKey: p.productKey,
+		version: p.version,
+		env,
+		gateKey,
+		perm,
+		objAdd,
+		objCollide,
+		ltAdd,
+		ltCollide,
+		actAdd,
+		actCollide,
+		deps,
+		linked,
+		osdkScopes: o.osdkScopes.slice(),
+		appRoutes: o.appRoutes.slice(),
+		requiredProjectRoles: o.requiredProjectRoles.slice(),
+		interfaces: ont.interfaces.slice(),
+		applySteps,
+		rollbackSteps,
+		blockers,
+		canApply: blockers.length === 0,
+		computedAt: nowStr()
+	};
+}
+const STEPS = [
+	"Draft",
+	"Plan",
+	"Release evidence",
+	"Apply"
+];
+/** Uppercase field label, matching object-type-wizard.tsx. */
+function FieldLabel({ children }) {
+	return /* @__PURE__ */ jsx(Label, {
+		className: "wwc:text-xs wwc:font-semibold wwc:tracking-wide wwc:text-muted-foreground wwc:uppercase",
+		children
+	});
+}
+function WizardSteps({ step }) {
+	return /* @__PURE__ */ jsx(Stepper, {
+		value: step + 1,
+		orientation: "horizontal",
+		className: "wwc:w-full",
+		children: /* @__PURE__ */ jsx(StepperList, {
+			className: "wwc:w-full",
+			children: STEPS.map((label, index) => /* @__PURE__ */ jsxs(React.Fragment, { children: [/* @__PURE__ */ jsxs(StepperItem, {
+				step: index + 1,
+				children: [/* @__PURE__ */ jsx(StepperIndicator, {}), /* @__PURE__ */ jsx(StepperLabel, { children: label })]
+			}), index < STEPS.length - 1 ? /* @__PURE__ */ jsx(StepperSeparator, {}) : null] }, label))
+		})
+	});
+}
+/**
+* The four release-evidence fields, in the order the Prod validation lists them. `errorLabel` is the
+* lowercase phrase the aggregated error joins; `label` is what the field shows.
+*/
+const EVIDENCE_FIELDS = [
+	{
+		key: "approvedBy",
+		label: "Approved by",
+		errorLabel: "approver name",
+		placeholder: "Name of the approver",
+		hint: "Recorded verbatim on the install record and in the changeset entry."
+	},
+	{
+		key: "releaseChannel",
+		label: "Release channel",
+		errorLabel: "release channel",
+		placeholder: "STABLE",
+		hint: "STABLE is the default channel used by the platform marketplace."
+	},
+	{
+		key: "promotionRunbookRef",
+		label: "Promotion runbook ref",
+		errorLabel: "promotion runbook ref",
+		placeholder: "runbooks/product-release-promotion.md",
+		hint: "Path to the runbook followed to promote this version.",
+		mono: true
+	},
+	{
+		key: "rollbackRunbookRef",
+		label: "Rollback runbook ref",
+		errorLabel: "rollback runbook ref",
+		placeholder: "runbooks/product-rollback.md",
+		hint: "Path to the runbook that reverses it — the same reversal this UI performs.",
+		mono: true
+	}
+];
+const EMPTY_EVIDENCE = {
+	approvedBy: "",
+	...DEFAULT_RELEASE_EVIDENCE
+};
+/** A manifest name chip. `title` carries the API name the primitive would take. */
+function NameChip({ children, title }) {
+	return /* @__PURE__ */ jsx(Badge, {
+		variant: "neutralSoft",
+		className: "wwc:font-mono wwc:font-normal",
+		title,
+		children
+	});
+}
+function MutedNote({ children }) {
+	return /* @__PURE__ */ jsx("span", {
+		className: "wwc:text-xs wwc:text-muted-foreground",
+		children
+	});
+}
+/** One of the plan step's four sub-cards, tightened for the dialog's scroll pane. */
+function PlanCard({ title, children }) {
+	return /* @__PURE__ */ jsxs(Card, { children: [/* @__PURE__ */ jsx(CardHeader, {
+		className: "wwc:p-3 wwc:pb-1.5",
+		children: /* @__PURE__ */ jsx(CardTitle, {
+			className: "wwc:text-xs wwc:font-semibold",
+			children: title
+		})
+	}), /* @__PURE__ */ jsx(CardContent, {
+		className: "wwc:p-3 wwc:pt-0",
+		children
+	})] });
+}
+/** The numbered apply / rollback order. Every generated step sentence is distinct, so it is its own key. */
+function StepList({ steps }) {
+	return /* @__PURE__ */ jsx("ol", {
+		className: "wwc:list-decimal wwc:space-y-1 wwc:pl-4",
+		children: steps.map((s) => /* @__PURE__ */ jsx("li", {
+			className: "wwc:text-xs wwc:text-muted-foreground",
+			children: s
+		}, s))
+	});
+}
+/** The stacked refusal rows — one danger Banner per blocker, in the plan's order. */
+function BlockerList({ blockers }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "wwc:space-y-2",
+		children: blockers.map((b) => /* @__PURE__ */ jsx(Banner, {
+			variant: "danger",
+			title: b.text
+		}, b.text))
+	});
+}
+/**
+* Four-step governed install: Draft → Plan → Release evidence → Apply.
+*
+* Blockers never stop navigation — you can plan, fill evidence and reach Apply with four refusals
+* visible. The block is enforced exactly once, when Apply is pressed, and the dialog then stays open
+* on the last step and toasts only the FIRST blocker. That is the prototype's behaviour and it is
+* deliberate: the flow is a review surface, not a gate.
+*/
+function InstallProductDialog({ open, onOpenChange, product, mode, installs, persona, onApply }) {
+	const [step, setStep] = React.useState(0);
+	const [attemptedNext, setAttemptedNext] = React.useState(false);
+	const [env, setEnv] = React.useState("Prod");
+	const [evidence, setEvidence] = React.useState(EMPTY_EVIDENCE);
+	const [plan, setPlan] = React.useState(null);
+	const reset = React.useCallback(() => {
+		setStep(0);
+		setAttemptedNext(false);
+		setEnv("Prod");
+		setEvidence(EMPTY_EVIDENCE);
+		setPlan(null);
+	}, []);
+	const productKey = product?.productKey;
+	React.useEffect(() => {
+		if (open) reset();
+	}, [
+		open,
+		productKey,
+		mode,
+		reset
+	]);
+	const handleOpenChange = (next) => {
+		if (!next) reset();
+		onOpenChange(next);
+	};
+	const gate = product ? roleGate(product, envGateKey(env), persona) : null;
+	const activePlan = React.useMemo(() => plan ?? (product ? computeInstallPlan(product, env, persona, installs) : null), [
+		plan,
+		product,
+		env,
+		persona,
+		installs
+	]);
+	const missingEvidence = EVIDENCE_FIELDS.filter((f) => evidence[f.key].trim().length === 0);
+	const evidenceError = env === "Prod" && missingEvidence.length > 0;
+	const showEvidenceError = attemptedNext && step === 2 && evidenceError;
+	const changeEnv = (next) => {
+		setEnv(next);
+		setPlan(null);
+		setAttemptedNext(false);
+	};
+	const setField = (key, value) => setEvidence((prev) => ({
+		...prev,
+		[key]: value
+	}));
+	const goNext = () => {
+		if (!product) return;
+		if (step === 2 && evidenceError) {
+			setAttemptedNext(true);
+			return;
+		}
+		if (step === 0 || step === 2) setPlan(computeInstallPlan(product, env, persona, installs));
+		setAttemptedNext(false);
+		setStep((value) => value + 1);
+	};
+	const goBack = () => {
+		setAttemptedNext(false);
+		setStep((value) => value - 1);
+	};
+	const apply = () => {
+		if (!product) return;
+		const fresh = computeInstallPlan(product, env, persona, installs);
+		setPlan(fresh);
+		if (!fresh.canApply) {
+			toast.error(fresh.blockers[0].text);
+			return;
+		}
+		if (env === "Prod" && missingEvidence.length > 0) {
+			toast.warning(`Prod installs need release evidence — missing: ${missingEvidence.map((f) => f.key).join(", ")}.`);
+			return;
+		}
+		onApply(buildInstallRecord(product, env, fresh, persona, evidence));
+		toast.success(`Installed product “${product.displayName}” ${product.version} into ${env} — added ${fresh.objAdd.length} object type(s), ${fresh.ltAdd.length} link type(s), ${fresh.actAdd.length} action type(s)`);
+		if (fresh.objCollide.length > 0) toast.warning(`${fresh.objCollide.length} object type(s) skipped — API name already taken: ${fresh.objCollide.map((c) => c.apiName).join(", ")}`);
+		handleOpenChange(false);
+	};
+	return /* @__PURE__ */ jsx(Dialog, {
+		open,
+		onOpenChange: handleOpenChange,
+		children: /* @__PURE__ */ jsx(DialogContent, {
+			className: "wwc:flex wwc:max-h-[92vh] wwc:w-[calc(100vw-2rem)] wwc:max-w-4xl wwc:flex-col wwc:gap-0 wwc:overflow-hidden wwc:p-0",
+			children: !product || !gate || !activePlan ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: mode === "upgrade" ? "Upgrade product" : "Install product" }) }), /* @__PURE__ */ jsx("div", {
+				className: "wwc:px-6 wwc:py-5 wwc:text-sm wwc:text-muted-foreground",
+				children: "This product no longer exists."
+			})] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsxs(DialogHeader, { children: [/* @__PURE__ */ jsx(DialogTitle, { children: `${mode === "upgrade" ? "Upgrade" : "Install"} ${product.displayName} ${product.version}` }), /* @__PURE__ */ jsx("span", {
+					className: "wwc:truncate wwc:text-xs wwc:text-muted-foreground",
+					children: `step ${step + 1} of ${STEPS.length} · acting as ${persona.name} (${persona.lens})`
+				})] }),
+				/* @__PURE__ */ jsx("div", {
+					className: "wwc:border-b wwc:border-border wwc:px-6 wwc:py-4",
+					children: /* @__PURE__ */ jsx(WizardSteps, { step })
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "wwc:min-h-0 wwc:flex-1 wwc:overflow-y-auto wwc:px-6 wwc:py-5",
+					children: [
+						step === 0 ? /* @__PURE__ */ jsxs("div", {
+							className: "wwc:space-y-4",
+							children: [
+								/* @__PURE__ */ jsxs("p", {
+									className: "wwc:text-sm wwc:text-muted-foreground",
+									children: [
+										"A WC3 install is a governed three-call lifecycle —",
+										" ",
+										/* @__PURE__ */ jsx("b", {
+											className: "wwc:font-semibold wwc:text-foreground",
+											children: "create install draft"
+										}),
+										" →",
+										" ",
+										/* @__PURE__ */ jsx("b", {
+											className: "wwc:font-semibold wwc:text-foreground",
+											children: "plan"
+										}),
+										" (preview against the live store) →",
+										" ",
+										/* @__PURE__ */ jsx("b", {
+											className: "wwc:font-semibold wwc:text-foreground",
+											children: "apply"
+										}),
+										". Nothing touches the ontology until Apply, and Apply is undoable from the changeset drawer."
+									]
+								}),
+								/* @__PURE__ */ jsxs("div", {
+									className: "wwc:space-y-1.5",
+									children: [
+										/* @__PURE__ */ jsx(FieldLabel, { children: "Target environment" }),
+										/* @__PURE__ */ jsxs(Select, {
+											value: env,
+											onValueChange: changeEnv,
+											children: [/* @__PURE__ */ jsx(SelectTrigger, {
+												className: "wwc:w-56",
+												"aria-label": "Target environment",
+												children: /* @__PURE__ */ jsx(SelectValue, {})
+											}), /* @__PURE__ */ jsx(SelectContent, { children: WC3_PRODUCT_ENVS.map((e) => /* @__PURE__ */ jsxs(SelectItem, {
+												value: e.env,
+												children: [e.env, " space"]
+											}, e.env)) })]
+										}),
+										/* @__PURE__ */ jsxs("p", {
+											className: "wwc:text-xs wwc:text-muted-foreground",
+											children: [
+												"The environment picks which of the manifest’s three install gates applies:",
+												" ",
+												/* @__PURE__ */ jsx("span", {
+													className: "wwc:font-mono",
+													children: gate.gateKey
+												}),
+												". A",
+												" ",
+												/* @__PURE__ */ jsx("b", {
+													className: "wwc:font-semibold wwc:text-foreground",
+													children: "Prod"
+												}),
+												" target additionally demands release evidence (approver, channel, promotion and rollback runbook refs)."
+											]
+										})
+									]
+								}),
+								/* @__PURE__ */ jsx(Banner, {
+									variant: gate.ok ? "success" : "danger",
+									title: gate.ok ? gateOkSentence(gate, persona) : gate.reason
+								}),
+								/* @__PURE__ */ jsxs(Card, { children: [/* @__PURE__ */ jsx(CardHeader, {
+									className: "wwc:p-3 wwc:pb-1.5",
+									children: /* @__PURE__ */ jsx(CardTitle, {
+										className: "wwc:text-xs wwc:font-semibold",
+										children: "What this draft targets"
+									})
+								}), /* @__PURE__ */ jsx(CardContent, {
+									className: "wwc:p-3 wwc:pt-0",
+									children: /* @__PURE__ */ jsxs(PropertyList, {
+										labelWidth: "9rem",
+										children: [
+											/* @__PURE__ */ jsxs(PropertyRow, {
+												label: "Product",
+												align: "start",
+												children: [
+													/* @__PURE__ */ jsx("span", { children: product.displayName }),
+													/* @__PURE__ */ jsx(Mono, { children: product.productKey }),
+													/* @__PURE__ */ jsx("span", { children: `${product.version} · ${product.productType}` })
+												]
+											}),
+											/* @__PURE__ */ jsx(PropertyRow, {
+												label: "Owner enclave",
+												children: /* @__PURE__ */ jsx(Mono, { children: product.ownerEnclaveId })
+											}),
+											/* @__PURE__ */ jsx(PropertyRow, {
+												label: "Declares",
+												align: "start",
+												children: productOutputSummary(product)
+											}),
+											/* @__PURE__ */ jsx(PropertyRow, {
+												label: "Dependencies",
+												align: "start",
+												children: product.dependencies.length > 0 ? product.dependencies.map((d) => `${d.productKey} ${d.versionRange} ${isInstalledIn(installs, d.productKey) ? "(installed)" : "(MISSING)"}`).join(", ") : /* @__PURE__ */ jsx(MutedNote, { children: "none" })
+											}),
+											/* @__PURE__ */ jsx(PropertyRow, {
+												label: "Linked products",
+												align: "start",
+												children: product.linkedProducts.length > 0 ? product.linkedProducts.map((l) => `${l.productKey} ${l.version} as ${l.role}`).join(", ") : /* @__PURE__ */ jsx(MutedNote, { children: "none" })
+											})
+										]
+									})
+								})] })
+							]
+						}) : null,
+						step === 1 ? /* @__PURE__ */ jsxs("div", {
+							className: "wwc:space-y-3",
+							"data-install-plan": product.productKey,
+							children: [
+								/* @__PURE__ */ jsxs("div", {
+									className: "wwc:grid wwc:grid-cols-2 wwc:gap-2 wwc:sm:grid-cols-3 wwc:lg:grid-cols-6",
+									children: [
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "object types ADD",
+											value: activePlan.objAdd.length
+										}),
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "object types COLLIDE",
+											value: activePlan.objCollide.length,
+											status: activePlan.objCollide.length > 0 ? "warning" : void 0
+										}),
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "link types ADD",
+											value: activePlan.ltAdd.length
+										}),
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "action types ADD",
+											value: activePlan.actAdd.length
+										}),
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "OSDK scopes",
+											value: activePlan.osdkScopes.length
+										}),
+										/* @__PURE__ */ jsx(MetricCard, {
+											title: "app routes",
+											value: activePlan.appRoutes.length
+										})
+									]
+								}),
+								/* @__PURE__ */ jsx("p", {
+									className: "wwc:text-xs wwc:text-muted-foreground",
+									children: `Computed at ${activePlan.computedAt} against the live store — ${WC3_OBJECT_TYPES.length} object types, ${WC3_LINK_TYPES.length} link types, ${WC3_ACTION_TYPES.length} action types right now.`
+								}),
+								activePlan.blockers.length > 0 ? /* @__PURE__ */ jsx(BlockerList, { blockers: activePlan.blockers }) : /* @__PURE__ */ jsx(Banner, {
+									variant: "success",
+									title: `Plan can apply — every gate, dependency and readiness check passes for ${persona.name} against ${env}.`
+								}),
+								activePlan.objCollide.length > 0 && /* @__PURE__ */ jsx(Banner, {
+									variant: "warning",
+									title: `${activePlan.objCollide.length} object type collision(s)`,
+									description: "These API names already exist in this store and will be SKIPPED, not overwritten:",
+									items: activePlan.objCollide.map((c) => `${c.apiName} (held by “${c.owner}”${c.ownerProduct ? `, installed by ${c.ownerProduct}` : ""})`)
+								}),
+								activePlan.ltCollide.length > 0 && /* @__PURE__ */ jsx(Banner, {
+									variant: "warning",
+									title: `${activePlan.ltCollide.length} link type collision(s)`,
+									description: "These API names already exist in this store and will be SKIPPED, not overwritten:",
+									items: activePlan.ltCollide.map((c) => c.apiName)
+								}),
+								activePlan.actCollide.length > 0 && /* @__PURE__ */ jsx(Banner, {
+									variant: "warning",
+									title: `${activePlan.actCollide.length} action type collision(s)`,
+									description: "These API names already exist in this store and will be SKIPPED, not overwritten:",
+									items: activePlan.actCollide.map((c) => c.apiName)
+								}),
+								/* @__PURE__ */ jsxs("div", {
+									className: "wwc:grid wwc:grid-cols-1 wwc:items-start wwc:gap-3 wwc:md:grid-cols-2",
+									children: [
+										/* @__PURE__ */ jsx(PlanCard, {
+											title: `Object types this apply would create (${activePlan.objAdd.length})`,
+											children: activePlan.objAdd.length > 0 ? /* @__PURE__ */ jsx("div", {
+												className: "wwc:flex wwc:flex-wrap wwc:gap-1.5",
+												children: activePlan.objAdd.map((s) => /* @__PURE__ */ jsx(NameChip, {
+													title: `API name it will take: ${s.apiName}`,
+													children: s.name
+												}, s.apiName))
+											}) : /* @__PURE__ */ jsx(MutedNote, { children: "Nothing new — every declared object type already exists." })
+										}),
+										/* @__PURE__ */ jsxs(PlanCard, {
+											title: `Link & action types (${activePlan.ltAdd.length} + ${activePlan.actAdd.length})`,
+											children: [/* @__PURE__ */ jsx("div", {
+												className: "wwc:flex wwc:flex-wrap wwc:gap-1.5",
+												children: activePlan.ltAdd.length > 0 ? activePlan.ltAdd.map((s) => /* @__PURE__ */ jsxs(NameChip, {
+													title: `API name it will take: ${s.apiName}`,
+													children: [/* @__PURE__ */ jsx(Link2, {}), s.name]
+												}, s.apiName)) : /* @__PURE__ */ jsx(MutedNote, { children: "no link types" })
+											}), /* @__PURE__ */ jsx("div", {
+												className: "wwc:mt-1.5 wwc:flex wwc:flex-wrap wwc:gap-1.5",
+												children: activePlan.actAdd.length > 0 ? activePlan.actAdd.map((s) => /* @__PURE__ */ jsxs(NameChip, {
+													title: `API name it will take: ${s.apiName}`,
+													children: [/* @__PURE__ */ jsx(Zap, {}), s.name]
+												}, s.apiName)) : /* @__PURE__ */ jsx(MutedNote, { children: "no action types" })
+											})]
+										}),
+										/* @__PURE__ */ jsx(PlanCard, {
+											title: `Apply order (${activePlan.applySteps.length})`,
+											children: /* @__PURE__ */ jsx(StepList, { steps: activePlan.applySteps })
+										}),
+										/* @__PURE__ */ jsx(PlanCard, {
+											title: `Rollback order (${activePlan.rollbackSteps.length})`,
+											children: /* @__PURE__ */ jsx(StepList, { steps: activePlan.rollbackSteps })
+										})
+									]
+								})
+							]
+						}) : null,
+						step === 2 ? /* @__PURE__ */ jsxs("div", {
+							className: "wwc:space-y-4",
+							children: [
+								env === "Prod" ? /* @__PURE__ */ jsx(Banner, {
+									variant: "warning",
+									title: "A Prod install cannot apply without release evidence — the approver and the two runbook refs are recorded on the install and shown in its lifecycle."
+								}) : /* @__PURE__ */ jsxs("p", {
+									className: "wwc:text-sm wwc:text-muted-foreground",
+									children: [
+										`Release evidence is not required for a `,
+										/* @__PURE__ */ jsx("b", {
+											className: "wwc:font-semibold wwc:text-foreground",
+											children: env
+										}),
+										` install, but anything you enter is still recorded against the install record.`
+									]
+								}),
+								/* @__PURE__ */ jsx("div", {
+									className: "wwc:grid wwc:grid-cols-1 wwc:gap-x-8 wwc:gap-y-5 wwc:md:grid-cols-2",
+									children: EVIDENCE_FIELDS.map((field) => {
+										const invalid = showEvidenceError && evidence[field.key].trim().length === 0;
+										return /* @__PURE__ */ jsxs("div", {
+											className: "wwc:space-y-1.5",
+											children: [
+												/* @__PURE__ */ jsxs(FieldLabel, { children: [field.label, env === "Prod" ? " *" : ""] }),
+												/* @__PURE__ */ jsx(Input, {
+													value: evidence[field.key],
+													placeholder: field.placeholder,
+													onChange: (event) => setField(field.key, event.target.value),
+													"aria-invalid": invalid,
+													className: cn(field.mono && "wwc:font-mono", invalid && "wwc:border-destructive wwc:focus-visible:ring-destructive")
+												}),
+												/* @__PURE__ */ jsx("p", {
+													className: "wwc:text-xs wwc:text-muted-foreground",
+													children: field.hint
+												})
+											]
+										}, field.key);
+									})
+								}),
+								showEvidenceError && /* @__PURE__ */ jsx("p", {
+									className: "wwc:text-xs wwc:text-destructive",
+									children: `A Prod install needs its release evidence — missing: ${missingEvidence.map((f) => f.errorLabel).join(", ")}.`
+								})
+							]
+						}) : null,
+						step === 3 ? /* @__PURE__ */ jsxs("div", {
+							className: "wwc:space-y-3",
+							children: [activePlan.canApply ? /* @__PURE__ */ jsx(Banner, {
+								variant: "success",
+								title: `Ready to apply. This records a governed install of ${activePlan.objAdd.length} object type(s), ${activePlan.ltAdd.length} link type(s) and ${activePlan.actAdd.length} action type(s) under the provenance of ${product.displayName} ${product.version}.`,
+								description: `The shared ontology fixture is a module constant, so this port writes the install record rather than mutating the store — the Ontology perspective still lists ${WC3_OBJECT_TYPES.length} object types.`
+							}) : /* @__PURE__ */ jsx(BlockerList, { blockers: activePlan.blockers }), /* @__PURE__ */ jsxs(Card, { children: [/* @__PURE__ */ jsx(CardHeader, {
+								className: "wwc:p-3 wwc:pb-1.5",
+								children: /* @__PURE__ */ jsx(CardTitle, {
+									className: "wwc:text-xs wwc:font-semibold",
+									children: "Install summary"
+								})
+							}), /* @__PURE__ */ jsx(CardContent, {
+								className: "wwc:p-3 wwc:pt-0",
+								children: /* @__PURE__ */ jsxs(PropertyList, {
+									labelWidth: "10rem",
+									children: [
+										/* @__PURE__ */ jsxs(PropertyRow, {
+											label: "Product",
+											align: "start",
+											children: [/* @__PURE__ */ jsx("span", { children: product.displayName }), /* @__PURE__ */ jsx(Mono, { children: `${product.productKey} ${product.version}` })]
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Environment",
+											align: "start",
+											children: /* @__PURE__ */ jsxs("span", { children: [
+												`${env} — gate `,
+												/* @__PURE__ */ jsx("span", {
+													className: "wwc:font-mono",
+													children: activePlan.gateKey
+												}),
+												activePlan.perm.ok ? ` satisfied by ${activePlan.perm.matched.join(", ")}` : " NOT satisfied"
+											] })
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Acting principal",
+											align: "start",
+											children: `${persona.name} · ${persona.lens} · roles ${personaRoles(persona).join(", ") || "none"}`
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Approved by",
+											children: evidence.approvedBy.trim() ? evidence.approvedBy : /* @__PURE__ */ jsx(MutedNote, { children: "not supplied" })
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Release channel",
+											children: /* @__PURE__ */ jsx(Mono, { children: evidence.releaseChannel.trim() || "—" })
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Promotion runbook",
+											align: "start",
+											children: /* @__PURE__ */ jsx(Mono, { children: evidence.promotionRunbookRef.trim() || "—" })
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Rollback runbook",
+											align: "start",
+											children: /* @__PURE__ */ jsx(Mono, { children: evidence.rollbackRunbookRef.trim() || "—" })
+										}),
+										/* @__PURE__ */ jsx(PropertyRow, {
+											label: "Skipped on collision",
+											children: `${activePlan.objCollide.length + activePlan.ltCollide.length + activePlan.actCollide.length} primitive(s)`
+										})
+									]
+								})
+							})] })]
+						}) : null
+					]
+				}),
+				/* @__PURE__ */ jsxs(DialogFooter, { children: [/* @__PURE__ */ jsxs("span", {
+					className: "wwc:text-sm wwc:text-muted-foreground",
+					children: [
+						"Step ",
+						step + 1,
+						" of ",
+						STEPS.length
+					]
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "wwc:flex wwc:items-center wwc:gap-2",
+					children: [step > 0 ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						onClick: goBack,
+						children: "← Back"
+					}) : null, step === 0 ? /* @__PURE__ */ jsxs(Button, {
+						onClick: goNext,
+						"data-install-next": step,
+						children: [/* @__PURE__ */ jsx(Play, {}), "Plan"]
+					}) : step < STEPS.length - 1 ? /* @__PURE__ */ jsx(Button, {
+						onClick: goNext,
+						"data-install-next": step,
+						children: "Next →"
+					}) : /* @__PURE__ */ jsxs(Button, {
+						onClick: apply,
+						"data-install-apply": product.productKey,
+						children: [/* @__PURE__ */ jsx(Check, {}), "Apply install"]
+					})]
+				})] })
+			] })
+		})
+	});
+}
+/**
+* The install record an apply would have written, shaped exactly like the four seeded WC3_INSTALLS so
+* the detail page's Installs section renders it without a special case.
+*
+* `addedObjectTypes` / `addedLinkTypes` / `addedActionTypes` carry the API names the plan reserved,
+* not live ontology ids — nothing was created, because WC3_OBJECT_TYPES is a module constant shared
+* with the Ontology perspective. Reporting the reserved names keeps the record's counts honest to the
+* plan; a consumer that resolves them against the live ontology will (correctly) find them absent.
+*/
+function buildInstallRecord(p, env, plan, persona, evidence) {
+	const when = nowStr();
+	const collisions = plan.objCollide.length + plan.ltCollide.length + plan.actCollide.length;
+	return {
+		id: `inst_${Math.floor(1e3 + Math.random() * 9e3)}`,
+		productKey: p.productKey,
+		version: p.version,
+		productType: p.productType,
+		environment: env,
+		status: "applied",
+		baseline: false,
+		approvedBy: evidence.approvedBy.trim(),
+		releaseChannel: evidence.releaseChannel.trim(),
+		promotionRunbookRef: evidence.promotionRunbookRef.trim(),
+		rollbackRunbookRef: evidence.rollbackRunbookRef.trim(),
+		installedBy: persona.name,
+		installedByLens: persona.lens,
+		when,
+		ts: Date.now(),
+		addedObjectTypes: plan.objAdd.map((s) => s.apiName),
+		addedLinkTypes: plan.ltAdd.map((s) => s.apiName),
+		addedActionTypes: plan.actAdd.map((s) => s.apiName),
+		skipped: {
+			objectTypes: plan.objCollide.map((c) => c.apiName),
+			linkTypes: plan.ltCollide.map((c) => c.apiName),
+			actionTypes: plan.actCollide.map((c) => c.apiName)
+		},
+		plan,
+		lifecycle: [
+			{
+				step: "create install draft",
+				by: persona.name,
+				when: plan.computedAt,
+				detail: `${p.productKey} ${p.version} → ${env}`
+			},
+			{
+				step: "plan (preview)",
+				by: persona.name,
+				when: plan.computedAt,
+				detail: `${plan.objAdd.length} object type(s), ${plan.ltAdd.length} link type(s), ${plan.actAdd.length} action type(s) to add · ${collisions} collision(s) skipped`
+			},
+			{
+				step: "apply",
+				by: persona.name,
+				when,
+				detail: `gate ${plan.gateKey} satisfied by ${plan.perm.matched.join(", ") || "n/a"}`
+			}
+		]
+	};
+}
+//#endregion
+export { InstallProductDialog, computeInstallPlan };
+
+//# sourceMappingURL=wc3-product-install-dialog.mjs.map