holarchy-core-logic 0.1.1

package/dist/authoring.d.ts

@@ -0,0 +1,44 @@
+import { type AggregateDiffDto, type AuthorDraftCommand, type DependencyImpactDto, type HolarchyChangeDto, type HolarchyChangeSetDto, type HolarchyDraftInput, type HolarchySnapshotDto, type HolonDiagnostic, type HolonDiagnosticCode, type PreviewBasisDto, type VersionFrontier } from "holarchy-core-contract";
+import type { JsonObject } from "depa-domain-protocol";
+import { type DesiredHolarchyFacts } from "./validator";
+export declare class AuthoringContractError extends Error {
+    readonly code: HolonDiagnosticCode;
+    readonly path: string;
+    constructor(code: HolonDiagnosticCode, path: string, message: string);
+}
+export declare function parseHolarchyChange(input: unknown, path: string): HolarchyChangeDto;
+export declare function parseHolarchyDraft(input: unknown, path?: string): HolarchyDraftInput;
+export declare function parseAuthorDraftCommand(input: unknown, path?: string): AuthorDraftCommand;
+export declare function sha256Basis(input: string): string;
+export type VersionEntity = keyof VersionFrontier;
+export interface PlannedIdentityCreate {
+    readonly entity: "OrganizationalSubject" | "Member" | "Holon" | "Role" | "GovernancePolicy" | "HolonMembership" | "RoleAssignment";
+    readonly values: JsonObject;
+}
+export interface PlannedVersionAppend {
+    readonly entity: VersionEntity;
+    readonly logicalId: string;
+    readonly logicalIdKey: "memberId" | "holonId" | "roleId" | "governancePolicyId" | "membershipId" | "roleAssignmentId";
+    readonly effectiveState: boolean;
+    readonly payload: JsonObject;
+}
+export interface HolarchyMutationPlanStep {
+    readonly change: HolarchyChangeDto;
+    readonly identities: readonly PlannedIdentityCreate[];
+    readonly version: PlannedVersionAppend;
+}
+export interface HolarchyChangeSetPlan {
+    readonly steps: readonly HolarchyMutationPlanStep[];
+    readonly facts: DesiredHolarchyFacts;
+    readonly before: HolarchySnapshotDto;
+    readonly after: HolarchySnapshotDto;
+    readonly aggregateDiff: AggregateDiffDto;
+    readonly dependencyImpacts: readonly DependencyImpactDto[];
+    readonly diagnostics: readonly HolonDiagnostic[];
+    readonly basis: PreviewBasisDto;
+    readonly valid: boolean;
+}
+export declare function projectHolarchySnapshot(facts: DesiredHolarchyFacts, effectiveDate: string): HolarchySnapshotDto;
+export declare function previewBasis(facts: DesiredHolarchyFacts, changeSet: Pick<HolarchyChangeSetDto, "id" | "revision" | "effectiveDate">): PreviewBasisDto;
+export declare function planHolarchyChangeSet(base: DesiredHolarchyFacts, changeSet: HolarchyChangeSetDto, executionInstant: string): HolarchyChangeSetPlan;
+//# sourceMappingURL=authoring.d.ts.map

package/dist/authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../src/authoring.ts"],"names":[],"mappings":"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"}

package/dist/authoring.js

@@ -0,0 +1,580 @@
+import { createHash } from "node:crypto";
+import { HOLON_CHANGE_KINDS, MEMBER_PRINCIPAL_KINDS, } from "holarchy-core-contract";
+import { isCanonicalDay } from "./effective";
+import { validateDesiredHolarchy } from "./validator";
+export class AuthoringContractError extends Error {
+    code;
+    path;
+    constructor(code, path, message) {
+        super(`${path}: ${message}`);
+        this.code = code;
+        this.path = path;
+        this.name = "AuthoringContractError";
+    }
+}
+const fail = (code, path, message) => {
+    throw new AuthoringContractError(code, path, message);
+};
+function object(value, path) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected an object");
+    let prototype;
+    let keys;
+    try {
+        prototype = Object.getPrototypeOf(value);
+        keys = Reflect.ownKeys(value);
+    }
+    catch {
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Object shape cannot be inspected safely");
+    }
+    if (prototype !== Object.prototype && prototype !== null)
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a plain object");
+    const normalized = Object.create(null);
+    for (const key of keys) {
+        if (typeof key === "symbol")
+            return fail("INVALID_CHANGE_PAYLOAD", path, "Symbol fields are not supported");
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(value, key);
+        }
+        catch {
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Field cannot be inspected safely");
+        }
+        if (descriptor === undefined || !("value" in descriptor))
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Accessor fields are not supported");
+        if (!descriptor.enumerable)
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Non-enumerable fields are not supported");
+        normalized[key] = descriptor.value;
+    }
+    return normalized;
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected an array");
+    let prototype;
+    let keys;
+    let lengthDescriptor;
+    try {
+        prototype = Object.getPrototypeOf(value);
+        keys = Reflect.ownKeys(value);
+        lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    }
+    catch {
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Array shape cannot be inspected safely");
+    }
+    if (prototype !== Array.prototype || lengthDescriptor === undefined || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value)) {
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a plain array");
+    }
+    const length = Number(lengthDescriptor.value);
+    for (const key of keys) {
+        if (typeof key === "symbol")
+            return fail("INVALID_CHANGE_PAYLOAD", path, "Symbol fields are not supported");
+        if (key === "length")
+            continue;
+        const index = Number(key);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= length || String(index) !== key) {
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Unsupported array field");
+        }
+    }
+    const normalized = [];
+    for (let index = 0; index < length; index += 1) {
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        }
+        catch {
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}[${index}]`, "Array item cannot be inspected safely");
+        }
+        if (descriptor === undefined)
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}[${index}]`, "Sparse arrays are not supported");
+        if (!("value" in descriptor))
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}[${index}]`, "Accessor array items are not supported");
+        if (!descriptor.enumerable)
+            return fail("INVALID_CHANGE_PAYLOAD", `${path}[${index}]`, "Non-enumerable array items are not supported");
+        normalized.push(descriptor.value);
+    }
+    return normalized;
+}
+function exactKeys(value, required, optional, path) {
+    for (const key of required)
+        if (!Object.hasOwn(value, key))
+            fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Required field is missing");
+    const allowed = new Set([...required, ...optional]);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            fail("INVALID_CHANGE_PAYLOAD", `${path}.${key}`, "Unsupported field");
+}
+function string(value, path) {
+    if (typeof value !== "string" || value.length === 0)
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a non-empty string");
+    return value;
+}
+function integer(value, path, minimum = 0) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum)
+        return fail("INVALID_CHANGE_PAYLOAD", path, `Expected an integer >= ${minimum}`);
+    return Number(value);
+}
+function nativeBoolean(value, path) {
+    if (typeof value !== "boolean")
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a native boolean");
+    return value;
+}
+function strings(value, path) {
+    return array(value, path).map((item, index) => string(item, `${path}[${index}]`));
+}
+function json(value, path, seen = new WeakSet()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a finite JSON number");
+        return value;
+    }
+    if (typeof value !== "object")
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Expected a JSON value");
+    if (seen.has(value))
+        return fail("INVALID_CHANGE_PAYLOAD", path, "Cyclic JSON values are not supported");
+    seen.add(value);
+    const normalized = Array.isArray(value)
+        ? array(value, path).map((item, index) => json(item, `${path}[${index}]`, seen))
+        : Object.fromEntries(Object.entries(object(value, path)).map(([key, item]) => [key, json(item, `${path}.${key}`, seen)]));
+    seen.delete(value);
+    return normalized;
+}
+function principalKind(value, path) {
+    if (typeof value === "string" && MEMBER_PRINCIPAL_KINDS.includes(value))
+        return value;
+    return fail("INVALID_CHANGE_PAYLOAD", path, `Expected one of ${MEMBER_PRINCIPAL_KINDS.join(", ")}`);
+}
+function parsePayload(kind, input, path) {
+    const value = object(input, path);
+    const empty = () => { exactKeys(value, [], [], path); return {}; };
+    switch (kind) {
+        case "MemberCreate":
+            exactKeys(value, ["subjectId", "displayName", "principalKind"], [], path);
+            return { subjectId: string(value.subjectId, `${path}.subjectId`), displayName: string(value.displayName, `${path}.displayName`), principalKind: principalKind(value.principalKind, `${path}.principalKind`) };
+        case "MemberRevise": {
+            if (Object.hasOwn(value, "subjectId"))
+                fail("FROZEN_SCOPE_DRIFT", `${path}.subjectId`, "Member subjectId is immutable");
+            exactKeys(value, [], ["displayName", "principalKind"], path);
+            if (!Object.hasOwn(value, "displayName") && !Object.hasOwn(value, "principalKind"))
+                fail("EMPTY_REVISION", path, "Member revision requires at least one field");
+            return {
+                ...(Object.hasOwn(value, "displayName") ? { displayName: string(value.displayName, `${path}.displayName`) } : {}),
+                ...(Object.hasOwn(value, "principalKind") ? { principalKind: principalKind(value.principalKind, `${path}.principalKind`) } : {}),
+            };
+        }
+        case "MemberDeactivate": return empty();
+        case "HolonCreate":
+            exactKeys(value, ["subjectId", "code", "name", "purpose", "boundary"], [], path);
+            return { subjectId: string(value.subjectId, `${path}.subjectId`), code: string(value.code, `${path}.code`), name: string(value.name, `${path}.name`), purpose: string(value.purpose, `${path}.purpose`), boundary: string(value.boundary, `${path}.boundary`) };
+        case "HolonRevise": {
+            for (const key of ["subjectId", "code"])
+                if (key in value)
+                    fail("FROZEN_SCOPE_DRIFT", `${path}.${key}`, `${key} is immutable`);
+            exactKeys(value, [], ["name", "purpose", "boundary"], path);
+            if (![value.name, value.purpose, value.boundary].some((item) => item !== undefined))
+                fail("EMPTY_REVISION", path, "Holon revision requires at least one field");
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, string(item, `${path}.${key}`)]));
+        }
+        case "HolonDeactivate": return empty();
+        case "RoleCreate": {
+            const required = ["holonId", "name", "purpose", "domains", "accountabilities", "policies", "capabilityRequirements"];
+            exactKeys(value, required, [], path);
+            return { holonId: string(value.holonId, `${path}.holonId`), name: string(value.name, `${path}.name`), purpose: string(value.purpose, `${path}.purpose`), domains: strings(value.domains, `${path}.domains`), accountabilities: strings(value.accountabilities, `${path}.accountabilities`), policies: strings(value.policies, `${path}.policies`), capabilityRequirements: strings(value.capabilityRequirements, `${path}.capabilityRequirements`) };
+        }
+        case "RoleRevise": {
+            if ("holonId" in value)
+                fail("FROZEN_SCOPE_DRIFT", `${path}.holonId`, "Role holonId is immutable");
+            const optional = ["name", "purpose", "domains", "accountabilities", "policies", "capabilityRequirements"];
+            exactKeys(value, [], optional, path);
+            if (!optional.some((key) => value[key] !== undefined))
+                fail("EMPTY_REVISION", path, "Role revision requires at least one field");
+            const parsed = {};
+            for (const key of optional)
+                if (value[key] !== undefined)
+                    parsed[key] = key === "name" || key === "purpose" ? string(value[key], `${path}.${key}`) : strings(value[key], `${path}.${key}`);
+            return parsed;
+        }
+        case "RoleDeactivate": return empty();
+        case "GovernancePolicyCreate":
+            exactKeys(value, ["holonId", "name", "profile", "rules"], [], path);
+            return { holonId: string(value.holonId, `${path}.holonId`), name: string(value.name, `${path}.name`), profile: string(value.profile, `${path}.profile`), rules: json(value.rules, `${path}.rules`) };
+        case "GovernancePolicyRevise": {
+            if ("holonId" in value)
+                fail("FROZEN_SCOPE_DRIFT", `${path}.holonId`, "GovernancePolicy holonId is immutable");
+            exactKeys(value, [], ["name", "profile", "rules"], path);
+            if (![value.name, value.profile, value.rules].some((item) => item !== undefined))
+                fail("EMPTY_REVISION", path, "GovernancePolicy revision requires at least one field");
+            return { ...(value.name === undefined ? {} : { name: string(value.name, `${path}.name`) }), ...(value.profile === undefined ? {} : { profile: string(value.profile, `${path}.profile`) }), ...(value.rules === undefined ? {} : { rules: json(value.rules, `${path}.rules`) }) };
+        }
+        case "GovernancePolicyDeactivate": return empty();
+        case "MembershipEstablish":
+        case "MembershipReconfigure": {
+            exactKeys(value, ["subjectId", "parentHolonId", "mode"], [], path);
+            const mode = value.mode;
+            if (mode !== "primary" && mode !== "affiliate")
+                fail("INVALID_CHANGE_PAYLOAD", `${path}.mode`, "Expected primary or affiliate");
+            return { subjectId: string(value.subjectId, `${path}.subjectId`), parentHolonId: string(value.parentHolonId, `${path}.parentHolonId`), mode: mode };
+        }
+        case "MembershipEnd": return empty();
+        case "RoleAssignmentEstablish":
+        case "RoleAssignmentReconfigure":
+            exactKeys(value, ["membershipId", "roleId"], [], path);
+            return { membershipId: string(value.membershipId, `${path}.membershipId`), roleId: string(value.roleId, `${path}.roleId`) };
+        case "RoleAssignmentEnd": return empty();
+    }
+}
+const TRUE_KINDS = new Set(HOLON_CHANGE_KINDS.filter((kind) => !kind.endsWith("Deactivate") && !kind.endsWith("End")));
+export function parseHolarchyChange(input, path) {
+    const value = object(input, path);
+    exactKeys(value, ["id", "order", "kind", "resourceId", "effectiveState", "payload"], [], path);
+    const rawKind = string(value.kind, `${path}.kind`);
+    if (!HOLON_CHANGE_KINDS.includes(rawKind))
+        fail("UNSUPPORTED_CHANGE", `${path}.kind`, `Unsupported Change kind ${rawKind}`);
+    const kind = rawKind;
+    const effectiveState = nativeBoolean(value.effectiveState, `${path}.effectiveState`);
+    if (effectiveState !== TRUE_KINDS.has(kind))
+        fail("INVALID_CHANGE_PAYLOAD", `${path}.effectiveState`, `${kind} requires effectiveState=${TRUE_KINDS.has(kind)}`);
+    return {
+        id: string(value.id, `${path}.id`), order: integer(value.order, `${path}.order`, 1), kind,
+        resourceId: string(value.resourceId, `${path}.resourceId`), effectiveState,
+        payload: parsePayload(kind, value.payload, `${path}.payload`),
+    };
+}
+export function parseHolarchyDraft(input, path = "$.invocation.payload.draft") {
+    const value = object(input, path);
+    exactKeys(value, ["id", "title", "effectiveDate", "actorRef", "changes"], [], path);
+    const changesInput = array(value.changes, `${path}.changes`);
+    const parsedChanges = changesInput.map((item, index) => parseHolarchyChange(item, `${path}.changes[${index}]`));
+    const orders = new Set();
+    const ids = new Set();
+    for (const [index, change] of parsedChanges.entries()) {
+        if (orders.has(change.order))
+            fail("DUPLICATE_RESOURCE", `${path}.changes[${index}].order`, `Duplicate Change order ${change.order}`);
+        if (ids.has(change.id))
+            fail("DUPLICATE_RESOURCE", `${path}.changes[${index}].id`, `Duplicate Change id ${change.id}`);
+        orders.add(change.order);
+        ids.add(change.id);
+    }
+    const effectiveDate = string(value.effectiveDate, `${path}.effectiveDate`);
+    if (!isCanonicalDay(effectiveDate))
+        fail("INVALID_TIMELINE", `${path}.effectiveDate`, "Expected a canonical YYYY-MM-DD date");
+    return { id: string(value.id, `${path}.id`), title: string(value.title, `${path}.title`), effectiveDate, actorRef: string(value.actorRef, `${path}.actorRef`), changes: [...parsedChanges].sort((left, right) => left.order - right.order) };
+}
+export function parseAuthorDraftCommand(input, path = "$.invocation.payload") {
+    const value = object(input, path);
+    const action = string(value.action, `${path}.action`);
+    if (action === "Create") {
+        exactKeys(value, ["action", "draft"], [], path);
+        return { action, draft: parseHolarchyDraft(value.draft, `${path}.draft`) };
+    }
+    if (action === "Replace") {
+        exactKeys(value, ["action", "expectedRevision", "draft"], [], path);
+        return { action, expectedRevision: integer(value.expectedRevision, `${path}.expectedRevision`, 1), draft: parseHolarchyDraft(value.draft, `${path}.draft`) };
+    }
+    if (action === "Delete") {
+        exactKeys(value, ["action", "expectedRevision"], [], path);
+        return { action, expectedRevision: integer(value.expectedRevision, `${path}.expectedRevision`, 1) };
+    }
+    return fail("INVALID_AUTHORING_ACTION", `${path}.action`, `Unsupported draft action ${action}`);
+}
+export function sha256Basis(input) {
+    return `sha256:${createHash("sha256").update(input).digest("hex")}`;
+}
+function latestAny(rows, key, id, day) {
+    return rows.filter((row) => String(row[key]) === id && row.effectiveDate <= day)
+        .sort((left, right) => left.effectiveDate.localeCompare(right.effectiveDate) || left.sequence - right.sequence).at(-1);
+}
+function cloneJson(value) { return JSON.parse(JSON.stringify(value)); }
+function eventMetadata(row) {
+    return { versionId: row.id, effectiveDate: row.effectiveDate, effectiveState: true, createdAt: row.createdAt, createdBy: row.createdBy, changeSetId: row.changeSetId, sequence: row.sequence };
+}
+function parseArray(value) { const parsed = JSON.parse(value); return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : []; }
+export function projectHolarchySnapshot(facts, effectiveDate) {
+    const subjectTypes = new Map(facts.subjects.map(({ id, subjectType }) => [id, subjectType]));
+    const members = facts.members.flatMap((identity) => { const version = latestAny(facts.memberVersions, "memberId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, subjectId: identity.subjectId, displayName: version.displayName, principalKind: version.principalKind, ...eventMetadata(version) }] : []; });
+    const holons = facts.holons.flatMap((identity) => { const version = latestAny(facts.holonVersions, "holonId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, subjectId: identity.subjectId, code: identity.code ?? identity.id, name: version.name, purpose: version.purpose, boundary: version.boundary, ...eventMetadata(version) }] : []; });
+    const memberships = facts.memberships.flatMap((identity) => { const version = latestAny(facts.membershipVersions, "membershipId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, subjectId: version.subjectId, subjectType: subjectTypes.get(version.subjectId) ?? "member", parentHolonId: version.parentHolonId, mode: version.mode, ...eventMetadata(version) }] : []; });
+    const roles = facts.roles.flatMap((identity) => { const version = latestAny(facts.roleVersions, "roleId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, holonId: identity.holonId, name: version.name, purpose: version.purpose, domains: parseArray(version.domainsJson), accountabilities: parseArray(version.accountabilitiesJson), policies: parseArray(version.policiesJson), capabilityRequirements: parseArray(version.capabilityRequirementsJson), ...eventMetadata(version) }] : []; });
+    const roleAssignments = facts.roleAssignments.flatMap((identity) => { const version = latestAny(facts.roleAssignmentVersions, "roleAssignmentId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, membershipId: version.membershipId, roleId: version.roleId, ...eventMetadata(version) }] : []; });
+    const governancePolicies = facts.governancePolicies.flatMap((identity) => { const version = latestAny(facts.governancePolicyVersions, "governancePolicyId", identity.id, effectiveDate); return version?.effectiveState === true ? [{ id: identity.id, holonId: identity.holonId, name: version.name, profile: version.profile, rules: JSON.parse(version.rulesJson), ...eventMetadata(version) }] : []; });
+    const byId = (rows) => [...rows].sort((left, right) => left.id.localeCompare(right.id));
+    return { effectiveDate, members: byId(members), holons: byId(holons), memberships: byId(memberships), roles: byId(roles), roleAssignments: byId(roleAssignments), governancePolicies: byId(governancePolicies) };
+}
+function resourceRows(snapshot) {
+    const value = (row) => cloneJson(row);
+    return [
+        ...snapshot.members.map((row) => ["Member", row.id, value(row)]),
+        ...snapshot.holons.map((row) => ["Holon", row.id, value(row)]),
+        ...snapshot.roles.map((row) => ["Role", row.id, value(row)]),
+        ...snapshot.governancePolicies.map((row) => ["GovernancePolicy", row.id, value(row)]),
+        ...snapshot.memberships.map((row) => ["Membership", row.id, value(row)]),
+        ...snapshot.roleAssignments.map((row) => ["RoleAssignment", row.id, value(row)]),
+    ];
+}
+function inactiveKeys(facts, day) {
+    const result = new Set();
+    const collect = (type, rows, key) => {
+        for (const id of new Set(rows.map((row) => String(row[key]))))
+            if (latestAny(rows, key, id, day)?.effectiveState === false)
+                result.add(`${type}:${id}`);
+    };
+    collect("Member", facts.memberVersions, "memberId");
+    collect("Holon", facts.holonVersions, "holonId");
+    collect("Membership", facts.membershipVersions, "membershipId");
+    collect("Role", facts.roleVersions, "roleId");
+    collect("RoleAssignment", facts.roleAssignmentVersions, "roleAssignmentId");
+    collect("GovernancePolicy", facts.governancePolicyVersions, "governancePolicyId");
+    return result;
+}
+function aggregateDiff(before, after, factsBefore) {
+    const beforeMap = new Map(resourceRows(before).map(([type, id, value]) => [`${type}:${id}`, { type, id, value }]));
+    const afterMap = new Map(resourceRows(after).map(([type, id, value]) => [`${type}:${id}`, { type, id, value }]));
+    const inactive = inactiveKeys(factsBefore, before.effectiveDate);
+    const items = [];
+    for (const key of [...new Set([...beforeMap.keys(), ...afterMap.keys()])].sort()) {
+        const prior = beforeMap.get(key), next = afterMap.get(key);
+        if (prior === undefined && next !== undefined)
+            items.push({ resourceType: next.type, resourceId: next.id, kind: inactive.has(key) ? "Reactivated" : "Added", after: next.value });
+        else if (prior !== undefined && next === undefined)
+            items.push({ resourceType: prior.type, resourceId: prior.id, kind: "Deactivated", before: prior.value });
+        else if (prior !== undefined && next !== undefined && JSON.stringify(prior.value) !== JSON.stringify(next.value))
+            items.push({ resourceType: prior.type, resourceId: prior.id, kind: "Changed", before: prior.value, after: next.value });
+    }
+    return { items, added: items.filter(({ kind }) => kind === "Added").length, changed: items.filter(({ kind }) => kind === "Changed").length, deactivated: items.filter(({ kind }) => kind === "Deactivated").length, reactivated: items.filter(({ kind }) => kind === "Reactivated").length };
+}
+function frontier(facts) {
+    const maximum = (rows) => Math.max(0, ...rows.map(({ sequence }) => sequence));
+    return { MemberVersion: maximum(facts.memberVersions), HolonVersion: maximum(facts.holonVersions), HolonMembershipVersion: maximum(facts.membershipVersions), RoleVersion: maximum(facts.roleVersions), RoleAssignmentVersion: maximum(facts.roleAssignmentVersions), GovernancePolicyVersion: maximum(facts.governancePolicyVersions) };
+}
+export function previewBasis(facts, changeSet) {
+    const authoritySequence = frontier(facts);
+    const canonical = JSON.stringify({ schema: "HolonPreviewBasis@1", changeSetId: changeSet.id, changeSetRevision: changeSet.revision, effectiveDate: changeSet.effectiveDate, authoritySequence });
+    return { schema: "HolonPreviewBasis@1", algorithm: "SHA-256", token: sha256Basis(canonical), changeSetId: changeSet.id, changeSetRevision: changeSet.revision, effectiveDate: changeSet.effectiveDate, authoritySequence };
+}
+export function planHolarchyChangeSet(base, changeSet, executionInstant) {
+    let facts = cloneJson(base);
+    let sequence = Math.max(0, ...Object.values(frontier(base)));
+    const steps = [];
+    const diagnostics = [];
+    const addDiagnostic = (code, path, message) => diagnostics.push({ code, path, message });
+    const hasIdentity = (kind, id) => ({ Member: facts.members, Holon: facts.holons, Membership: facts.memberships, Role: facts.roles, RoleAssignment: facts.roleAssignments, GovernancePolicy: facts.governancePolicies }[kind]).some((row) => row.id === id);
+    const metadata = (change, path) => ({ id: `${change.id}:preview`, effectiveDate: changeSet.effectiveDate, effectiveState: change.effectiveState, createdAt: executionInstant, createdBy: changeSet.actorRef, changeSetId: changeSet.id, sequence: ++sequence, path });
+    const appendStep = (change, identities, version) => steps.push(Object.freeze({ change, identities: Object.freeze([...identities]), version: Object.freeze({ ...version, payload: Object.freeze({ ...version.payload }) }) }));
+    for (const [index, change] of [...changeSet.changes].sort((left, right) => left.order - right.order).entries()) {
+        const path = `$.changeSet.changes[${index}]`, identities = [];
+        const missing = (type) => { addDiagnostic("MISSING_IDENTITY", `${path}.resourceId`, `${type} ${change.resourceId} does not exist`); };
+        const duplicate = (type) => { addDiagnostic("DUPLICATE_RESOURCE", `${path}.resourceId`, `${type} ${change.resourceId} already exists`); };
+        switch (change.kind) {
+            case "MemberCreate": {
+                if (hasIdentity("Member", change.resourceId) || facts.subjects.some(({ id }) => id === change.payload.subjectId)) {
+                    duplicate("Member");
+                    break;
+                }
+                identities.push({ entity: "OrganizationalSubject", values: { id: change.payload.subjectId, subjectType: "member" } }, { entity: "Member", values: { id: change.resourceId, subjectId: change.payload.subjectId } });
+                const payload = { displayName: change.payload.displayName, principalKind: change.payload.principalKind };
+                facts = { ...facts, subjects: [...facts.subjects, { id: change.payload.subjectId, subjectType: "member" }], members: [...facts.members, { id: change.resourceId, subjectId: change.payload.subjectId }], memberVersions: [...facts.memberVersions, { ...metadata(change, path), memberId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "MemberVersion", logicalId: change.resourceId, logicalIdKey: "memberId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "MemberRevise":
+            case "MemberDeactivate": {
+                const current = latestAny(facts.memberVersions, "memberId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("Member", change.resourceId) || current === undefined) {
+                    missing("Member");
+                    break;
+                }
+                const payload = change.kind === "MemberRevise"
+                    ? { displayName: change.payload.displayName ?? current.displayName, principalKind: change.payload.principalKind ?? current.principalKind }
+                    : { displayName: current.displayName, principalKind: current.principalKind };
+                facts = { ...facts, memberVersions: [...facts.memberVersions, { ...metadata(change, path), memberId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "MemberVersion", logicalId: change.resourceId, logicalIdKey: "memberId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "HolonCreate": {
+                if (hasIdentity("Holon", change.resourceId) || facts.subjects.some(({ id }) => id === change.payload.subjectId)) {
+                    duplicate("Holon");
+                    break;
+                }
+                identities.push({ entity: "OrganizationalSubject", values: { id: change.payload.subjectId, subjectType: "holon" } }, { entity: "Holon", values: { id: change.resourceId, subjectId: change.payload.subjectId, code: change.payload.code } });
+                facts = { ...facts, subjects: [...facts.subjects, { id: change.payload.subjectId, subjectType: "holon" }], holons: [...facts.holons, { id: change.resourceId, subjectId: change.payload.subjectId, code: change.payload.code }], holonVersions: [...facts.holonVersions, { ...metadata(change, path), holonId: change.resourceId, name: change.payload.name, purpose: change.payload.purpose, boundary: change.payload.boundary }] };
+                appendStep(change, identities, { entity: "HolonVersion", logicalId: change.resourceId, logicalIdKey: "holonId", effectiveState: change.effectiveState, payload: { name: change.payload.name, purpose: change.payload.purpose, boundary: change.payload.boundary } });
+                break;
+            }
+            case "HolonRevise":
+            case "HolonDeactivate": {
+                const current = latestAny(facts.holonVersions, "holonId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("Holon", change.resourceId) || current === undefined) {
+                    missing("Holon");
+                    break;
+                }
+                const payload = change.kind === "HolonRevise" ? { name: change.payload.name ?? current.name, purpose: change.payload.purpose ?? current.purpose, boundary: change.payload.boundary ?? current.boundary } : { name: current.name, purpose: current.purpose, boundary: current.boundary };
+                facts = { ...facts, holonVersions: [...facts.holonVersions, { ...metadata(change, path), holonId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "HolonVersion", logicalId: change.resourceId, logicalIdKey: "holonId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "RoleCreate": {
+                if (hasIdentity("Role", change.resourceId)) {
+                    duplicate("Role");
+                    break;
+                }
+                identities.push({ entity: "Role", values: { id: change.resourceId, holonId: change.payload.holonId } });
+                const payload = { name: change.payload.name, purpose: change.payload.purpose, domainsJson: JSON.stringify(change.payload.domains), accountabilitiesJson: JSON.stringify(change.payload.accountabilities), policiesJson: JSON.stringify(change.payload.policies), capabilityRequirementsJson: JSON.stringify(change.payload.capabilityRequirements) };
+                facts = { ...facts, roles: [...facts.roles, { id: change.resourceId, holonId: change.payload.holonId }], roleVersions: [...facts.roleVersions, { ...metadata(change, path), roleId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "RoleVersion", logicalId: change.resourceId, logicalIdKey: "roleId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "RoleRevise":
+            case "RoleDeactivate": {
+                const current = latestAny(facts.roleVersions, "roleId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("Role", change.resourceId) || current === undefined) {
+                    missing("Role");
+                    break;
+                }
+                const revision = change.kind === "RoleRevise" ? change.payload : {};
+                const payload = { name: revision.name ?? current.name, purpose: revision.purpose ?? current.purpose, domainsJson: revision.domains === undefined ? current.domainsJson : JSON.stringify(revision.domains), accountabilitiesJson: revision.accountabilities === undefined ? current.accountabilitiesJson : JSON.stringify(revision.accountabilities), policiesJson: revision.policies === undefined ? current.policiesJson : JSON.stringify(revision.policies), capabilityRequirementsJson: revision.capabilityRequirements === undefined ? current.capabilityRequirementsJson : JSON.stringify(revision.capabilityRequirements) };
+                facts = { ...facts, roleVersions: [...facts.roleVersions, { ...metadata(change, path), roleId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "RoleVersion", logicalId: change.resourceId, logicalIdKey: "roleId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "GovernancePolicyCreate": {
+                if (hasIdentity("GovernancePolicy", change.resourceId)) {
+                    duplicate("GovernancePolicy");
+                    break;
+                }
+                identities.push({ entity: "GovernancePolicy", values: { id: change.resourceId, holonId: change.payload.holonId } });
+                const payload = { holonId: change.payload.holonId, name: change.payload.name, profile: change.payload.profile, rulesJson: JSON.stringify(change.payload.rules) };
+                facts = { ...facts, governancePolicies: [...facts.governancePolicies, { id: change.resourceId, holonId: change.payload.holonId }], governancePolicyVersions: [...facts.governancePolicyVersions, { ...metadata(change, path), governancePolicyId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "GovernancePolicyVersion", logicalId: change.resourceId, logicalIdKey: "governancePolicyId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "GovernancePolicyRevise":
+            case "GovernancePolicyDeactivate": {
+                const current = latestAny(facts.governancePolicyVersions, "governancePolicyId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("GovernancePolicy", change.resourceId) || current === undefined) {
+                    missing("GovernancePolicy");
+                    break;
+                }
+                const revision = change.kind === "GovernancePolicyRevise" ? change.payload : {};
+                const payload = { holonId: current.holonId, name: revision.name ?? current.name, profile: revision.profile ?? current.profile, rulesJson: revision.rules === undefined ? current.rulesJson : JSON.stringify(revision.rules) };
+                facts = { ...facts, governancePolicyVersions: [...facts.governancePolicyVersions, { ...metadata(change, path), governancePolicyId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "GovernancePolicyVersion", logicalId: change.resourceId, logicalIdKey: "governancePolicyId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "MembershipEstablish": {
+                if (hasIdentity("Membership", change.resourceId)) {
+                    duplicate("Membership");
+                    break;
+                }
+                identities.push({ entity: "HolonMembership", values: { id: change.resourceId } });
+                const payload = { subjectId: change.payload.subjectId, parentHolonId: change.payload.parentHolonId, mode: change.payload.mode };
+                facts = { ...facts, memberships: [...facts.memberships, { id: change.resourceId }], membershipVersions: [...facts.membershipVersions, { ...metadata(change, path), membershipId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "HolonMembershipVersion", logicalId: change.resourceId, logicalIdKey: "membershipId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "MembershipReconfigure":
+            case "MembershipEnd": {
+                const current = latestAny(facts.membershipVersions, "membershipId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("Membership", change.resourceId) || current === undefined) {
+                    missing("Membership");
+                    break;
+                }
+                if (change.kind === "MembershipReconfigure" && change.payload.subjectId !== current.subjectId) {
+                    addDiagnostic("FROZEN_SCOPE_DRIFT", `${path}.payload.subjectId`, "Membership subjectId is immutable");
+                    break;
+                }
+                const payload = change.kind === "MembershipReconfigure" ? { subjectId: change.payload.subjectId, parentHolonId: change.payload.parentHolonId, mode: change.payload.mode } : { subjectId: current.subjectId, parentHolonId: current.parentHolonId, mode: current.mode };
+                facts = { ...facts, membershipVersions: [...facts.membershipVersions, { ...metadata(change, path), membershipId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "HolonMembershipVersion", logicalId: change.resourceId, logicalIdKey: "membershipId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "RoleAssignmentEstablish": {
+                if (hasIdentity("RoleAssignment", change.resourceId)) {
+                    duplicate("RoleAssignment");
+                    break;
+                }
+                identities.push({ entity: "RoleAssignment", values: { id: change.resourceId } });
+                const payload = { membershipId: change.payload.membershipId, roleId: change.payload.roleId };
+                facts = { ...facts, roleAssignments: [...facts.roleAssignments, { id: change.resourceId }], roleAssignmentVersions: [...facts.roleAssignmentVersions, { ...metadata(change, path), roleAssignmentId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "RoleAssignmentVersion", logicalId: change.resourceId, logicalIdKey: "roleAssignmentId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+            case "RoleAssignmentReconfigure":
+            case "RoleAssignmentEnd": {
+                const current = latestAny(facts.roleAssignmentVersions, "roleAssignmentId", change.resourceId, changeSet.effectiveDate);
+                if (!hasIdentity("RoleAssignment", change.resourceId) || current === undefined) {
+                    missing("RoleAssignment");
+                    break;
+                }
+                if (change.kind === "RoleAssignmentReconfigure" && change.payload.membershipId === current.membershipId && change.payload.roleId === current.roleId) {
+                    addDiagnostic("EMPTY_REVISION", `${path}.payload`, "RoleAssignment reconfiguration must change membershipId or roleId");
+                    break;
+                }
+                const payload = change.kind === "RoleAssignmentReconfigure" ? { membershipId: change.payload.membershipId, roleId: change.payload.roleId } : { membershipId: current.membershipId, roleId: current.roleId };
+                facts = { ...facts, roleAssignmentVersions: [...facts.roleAssignmentVersions, { ...metadata(change, path), roleAssignmentId: change.resourceId, ...payload }] };
+                appendStep(change, identities, { entity: "RoleAssignmentVersion", logicalId: change.resourceId, logicalIdKey: "roleAssignmentId", effectiveState: change.effectiveState, payload });
+                break;
+            }
+        }
+    }
+    const before = projectHolarchySnapshot(base, changeSet.effectiveDate), after = projectHolarchySnapshot(facts, changeSet.effectiveDate);
+    const afterMembershipIds = new Set(after.memberships.map(({ id }) => id)), afterRoleIds = new Set(after.roles.map(({ id }) => id)), afterAssignmentIds = new Set(after.roleAssignments.map(({ id }) => id));
+    const explicitlyHandledAssignments = new Set(steps
+        .filter(({ change }) => change.kind === "RoleAssignmentEnd" || change.kind === "RoleAssignmentReconfigure")
+        .map(({ change }) => change.resourceId));
+    const impacts = [];
+    const impact = (change, index, resourceType, resourceId, resolved, message) => {
+        if (impacts.some((item) => item.changeId === change.id && item.resourceType === resourceType && item.resourceId === resourceId))
+            return;
+        impacts.push({ changeId: change.id, resourceType, resourceId, resolution: resolved ? "ResolvedInBatch" : "BlocksApply", path: `$.changeSet.changes[${index}]`, message });
+        if (!resolved)
+            addDiagnostic("DEPENDENCY_BLOCKS_APPLY", `$.changeSet.changes[${index}]`, message);
+    };
+    for (const [index, change] of [...changeSet.changes].sort((left, right) => left.order - right.order).entries()) {
+        if (change.kind === "MemberDeactivate") {
+            const subjectId = base.members.find(({ id }) => id === change.resourceId)?.subjectId;
+            for (const membership of before.memberships.filter((item) => item.subjectId === subjectId)) {
+                impact(change, index, "Membership", membership.id, !afterMembershipIds.has(membership.id), `Membership ${membership.id} depends on Member ${change.resourceId}`);
+                for (const assignment of before.roleAssignments.filter((item) => item.membershipId === membership.id))
+                    impact(change, index, "RoleAssignment", assignment.id, !afterAssignmentIds.has(assignment.id), `RoleAssignment ${assignment.id} depends on Member ${change.resourceId}`);
+            }
+        }
+        else if (change.kind === "HolonDeactivate") {
+            const subjectId = base.holons.find(({ id }) => id === change.resourceId)?.subjectId;
+            const affectedMemberships = before.memberships.filter((item) => item.parentHolonId === change.resourceId || item.subjectId === subjectId);
+            const affectedRoles = before.roles.filter((item) => item.holonId === change.resourceId);
+            for (const membership of affectedMemberships)
+                impact(change, index, "Membership", membership.id, !afterMembershipIds.has(membership.id), `Membership ${membership.id} depends on Holon ${change.resourceId}`);
+            for (const role of affectedRoles)
+                impact(change, index, "Role", role.id, !afterRoleIds.has(role.id), `Role ${role.id} depends on Holon ${change.resourceId}`);
+            const membershipIds = new Set(affectedMemberships.map(({ id }) => id)), roleIds = new Set(affectedRoles.map(({ id }) => id));
+            for (const assignment of before.roleAssignments.filter((item) => membershipIds.has(item.membershipId) || roleIds.has(item.roleId)))
+                impact(change, index, "RoleAssignment", assignment.id, !afterAssignmentIds.has(assignment.id), `RoleAssignment ${assignment.id} depends on Holon ${change.resourceId}`);
+            for (const policy of before.governancePolicies.filter((item) => item.holonId === change.resourceId))
+                impact(change, index, "GovernancePolicy", policy.id, !after.governancePolicies.some(({ id }) => id === policy.id), `GovernancePolicy ${policy.id} depends on Holon ${change.resourceId}`);
+        }
+        else if (change.kind === "RoleDeactivate") {
+            for (const assignment of before.roleAssignments.filter((item) => item.roleId === change.resourceId))
+                impact(change, index, "RoleAssignment", assignment.id, !afterAssignmentIds.has(assignment.id), `RoleAssignment ${assignment.id} depends on Role ${change.resourceId}`);
+        }
+        else if (change.kind === "MembershipEnd" || change.kind === "MembershipReconfigure") {
+            for (const assignment of before.roleAssignments.filter((item) => item.membershipId === change.resourceId)) {
+                const afterAssignment = after.roleAssignments.find(({ id }) => id === assignment.id);
+                const movedOrEnded = afterAssignment === undefined || afterAssignment.membershipId !== change.resourceId;
+                const afterMembership = after.memberships.find(({ id }) => id === change.resourceId);
+                const afterRole = afterAssignment === undefined ? undefined : after.roles.find(({ id }) => id === afterAssignment.roleId);
+                const remainsValidAfterReconfigure = change.kind === "MembershipReconfigure"
+                    && afterMembership !== undefined
+                    && afterRole !== undefined
+                    && afterMembership.parentHolonId === afterRole.holonId;
+                const resolved = explicitlyHandledAssignments.has(assignment.id) && (movedOrEnded || remainsValidAfterReconfigure);
+                impact(change, index, "RoleAssignment", assignment.id, resolved, `RoleAssignment ${assignment.id} depends on Membership ${change.resourceId}`);
+            }
+        }
+    }
+    diagnostics.push(...validateDesiredHolarchy(facts, changeSet.effectiveDate));
+    const uniqueDiagnostics = diagnostics.filter((item, index) => diagnostics.findIndex((candidate) => candidate.code === item.code && candidate.path === item.path && candidate.message === item.message) === index);
+    return Object.freeze({ steps: Object.freeze(steps), facts, before, after, aggregateDiff: aggregateDiff(before, after, base), dependencyImpacts: Object.freeze(impacts), diagnostics: Object.freeze(uniqueDiagnostics), basis: previewBasis(base, changeSet), valid: uniqueDiagnostics.length === 0 });
+}
+//# sourceMappingURL=authoring.js.map