@dialecte/scl 0.3.2 → 0.3.4

package/dist/v2019C1/extensions/lifecycle/contract.types.d.ts

@@ -0,0 +1,53 @@
+import { Scl, Config } from '../../config';
+import { DecisionMap, DiffReport } from './engine/diff.types';
+import type * as Core from '@dialecte/core';
+/** Which template layer the lifecycle surface operates on. */
+export type LifecycleVerb = 'fsd' | 'asd';
+/**
+ * Which lifecycle operation the user chose:
+ *  - `instantiate` — place a NEW instance of the template (duplicates allowed;
+ *    a sibling name collision is resolved). Re-applying the same template yields
+ *    another instance, never a silent no-op.
+ *  - `update` — reconcile the template onto its EXISTING instance(s).
+ *
+ * Picked explicitly by the consumer — it cannot be inferred reliably (a same-
+ * version re-upload is a valid duplicate). Defaults to `update` for back-compat.
+ */
+export type LifecycleScenario = 'instantiate' | 'update';
+/**
+ * What to reconcile and where — the uniform `{ verb, sourceQuery, ref, anchor }`
+ * descriptor shared by `report` (read-only classify) and `apply` (write).
+ * Discriminated on `verb` so `ref` narrows to the right element type.
+ */
+export type LifecycleTarget = {
+    verb: 'fsd';
+    sourceQuery: Core.Query<Config>;
+    /** The source (template) Function to reconcile. */
+    ref: Scl.Ref<'Function'>;
+    /** Target parent the instance lives under / is placed into. */
+    anchor: Scl.Ref<Scl.ElementsOf>;
+    /** Operation to perform. Defaults to `update`. */
+    scenario?: LifecycleScenario;
+} | {
+    verb: 'asd';
+    sourceQuery: Core.Query<Config>;
+    /** The source (template) Application to reconcile. */
+    ref: Scl.Ref<'Application'>;
+    /** Target parent the composed functions are placed into. */
+    anchor: Scl.Ref<Scl.ElementsOf>;
+    /** Operation to perform. Defaults to `update`. */
+    scenario?: LifecycleScenario;
+};
+/**
+ * `apply` inputs: the target plus the `report` produced by `report` (the
+ * consumer classifies first, then applies). The report gates the track.
+ *
+ * `decisions` drives the full track: absent -> the caller has not decided yet
+ * (apply writes nothing and returns the report); present -> apply the accepted
+ * groups only (a group absent from the map defaults to accept).
+ */
+export type LifecycleApplyParams = LifecycleTarget & {
+    report: DiffReport;
+    decisions?: DecisionMap;
+};
+//# sourceMappingURL=contract.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/contract.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.types.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/extensions/lifecycle/contract.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAA;AAC/F,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,8DAA8D;AAC9D,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,CAAA;AAEzC;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,QAAQ,CAAA;AAExD;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB;IACA,IAAI,EAAE,KAAK,CAAA;IACX,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,mDAAmD;IACnD,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACxB,+DAA+D;IAC/D,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC3B,GACD;IACA,IAAI,EAAE,KAAK,CAAA;IACX,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,sDAAsD;IACtD,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IAC3B,4DAA4D;IAC5D,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAEJ;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,WAAW,CAAA;CAAE,CAAA"}

package/dist/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CROSS-CUTTING satellite containers: elements that apply to ANY SCL element
+ * (via a uuid reference into it) and therefore travel with WHATEVER subtree
+ * contains their target — not owned by a single layer (90-30 §12.1 / §13.1).
+ *
+ * v1 = `Variable` (via `VariableApplyTo.elementUuid`) and `BehaviorDescription`
+ * (via `InputVar`/`OutputVar.lnodeUuid`). Only uuid-bound targets are covered;
+ * XPath-selector variables (no `elementUuid`) need XPath resolution (see TO_DO.md)
+ * and are deferred.
+ */
+export declare const CROSS_CUTTING_SATELLITE_CONTAINERS: readonly ["Variable", "BehaviorDescription"];
+//# sourceMappingURL=applied-satellites.constants.d.ts.map

package/dist/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applied-satellites.constants.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,8CAA+C,CAAA"}

package/dist/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.d.ts

@@ -0,0 +1,13 @@
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Resolve the cross-cutting satellites that apply to ANY element within the
+ * primary's subtree: for every uuid-bearing element under `primaryRef`, find the
+ * containers (e.g. `Variable`) referencing it. Excludes containers that live
+ * INSIDE the subtree (internal — already carried by the primary clone/diff). This
+ * is layer-agnostic: any verb passes its primary and gets the applied satellites.
+ */
+export declare function resolveAppliedSatellites(query: Core.Query<Config>, params: {
+    primaryRef: Scl.Ref<Scl.ElementsOf>;
+}): Promise<Scl.Ref<Scl.ElementsOf>[]>;
+//# sourceMappingURL=applied-satellites.d.ts.map

package/dist/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applied-satellites.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/cross-cutting/applied-satellites.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAG3C;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE;IAAE,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;CAAE,GAC7C,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CA4BpC"}

package/dist/v2019C1/extensions/lifecycle/cross-cutting/clone-applied-satellites.d.ts

@@ -0,0 +1,24 @@
+import { Config, Scl } from '../../../config';
+import { TargetStructure } from '../transplant/transaction';
+import type * as Core from '@dialecte/core';
+/**
+ * Clones the external CROSS-CUTTING satellites (e.g. `Variable`,
+ * `BehaviorDescription`) that apply to any element in the primary subtree, each
+ * placed at its source structural level. Tag-agnostic: whatever
+ * `resolveAppliedSatellites` returns is cloned by its own tag. Satellites living
+ * inside the subtree are cloned by `deep`, not here (the resolver excludes them).
+ * UUID remapping is handled by the afterDeepClone hook; the caller stamps lineage
+ * via `writeIdentity`.
+ *
+ * A satellite whose same-tag/same-name twin already exists in the target IS that
+ * shared entity: its referencing children (`VariableApplyTo`, `InputVar`/`OutputVar`,
+ * ...) are ADDED to the existing satellite rather than the whole thing being skipped -
+ * skipping would drop the application to the newly-instantiated element.
+ */
+export declare function cloneAppliedSatellites(tx: Core.Transaction<Config>, params: {
+    sourceQuery: Core.Query<Config>;
+    primaryRef: Scl.Ref<Scl.ElementsOf>;
+    structure: TargetStructure;
+    strip?: boolean;
+}): Promise<Scl.CloneMapping[]>;
+//# sourceMappingURL=clone-applied-satellites.d.ts.map

package/dist/v2019C1/extensions/lifecycle/cross-cutting/clone-applied-satellites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-applied-satellites.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/cross-cutting/clone-applied-satellites.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uDAAuD,CAAA;AAC5F,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAC3C,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACnC,SAAS,EAAE,eAAe,CAAA;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAA;CACf,GACC,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CA6B7B"}

package/dist/v2019C1/extensions/lifecycle/cross-cutting/index.d.ts

@@ -0,0 +1,4 @@
+export { resolveAppliedSatellites } from './applied-satellites';
+export { CROSS_CUTTING_SATELLITE_CONTAINERS } from './applied-satellites.constants';
+export { cloneAppliedSatellites } from './clone-applied-satellites';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/lifecycle/cross-cutting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/cross-cutting/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,kCAAkC,EAAE,MAAM,gCAAgC,CAAA;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/v2019C1/extensions/lifecycle/engine/decide.d.ts

@@ -0,0 +1,31 @@
+import { AcceptedIds, CollisionOverrides } from './decide.types';
+import { DecisionGroup, DecisionMap, GroupDecision } from './diff.types';
+/** The action of a decision (absent -> accept; string or object form). */
+export declare function decisionAction(decision: GroupDecision | undefined): 'accept' | 'skip';
+/**
+ * The user-edited values for each accepted group, keyed by the primary's SOURCE id
+ * (the placed element is matched by its source at instantiate time). Skipped groups
+ * and groups with no edits are omitted.
+ */
+export declare function collisionOverrides(params: {
+    groups: DecisionGroup[];
+    decisions: DecisionMap;
+}): CollisionOverrides;
+/**
+ * Dependency guard (07 §4): reject a decision set that accepts a group whose
+ * `dependsOn` parent is skipped. Runs before any write.
+ */
+export declare function assertDecisionsCoherent(params: {
+    groups: DecisionGroup[];
+    decisions: DecisionMap;
+}): void;
+/**
+ * Collect the record ids reconcile may write, from every accepted group's
+ * primary + companions. Added/modified nodes contribute their `sourceRef`
+ * (reconcile matches/adds by source); removed nodes contribute `instanceRef`.
+ */
+export declare function acceptedRefIds(params: {
+    groups: DecisionGroup[];
+    decisions: DecisionMap;
+}): AcceptedIds;
+//# sourceMappingURL=decide.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/decide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/decide.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAY,aAAa,EAAE,MAAM,cAAc,CAAA;AAEvF,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAIrF;AAYD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,SAAS,EAAE,WAAW,CAAA;CACtB,GAAG,kBAAkB,CAWrB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC/C,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,SAAS,EAAE,WAAW,CAAA;CACtB,GAAG,IAAI,CAUP;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,SAAS,EAAE,WAAW,CAAA;CACtB,GAAG,WAAW,CAad"}

package/dist/v2019C1/extensions/lifecycle/engine/decide.types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The record ids reconcile is allowed to touch, derived from the accepted
+ * groups. `sourceIds` gate updates/adds (matched by the source element);
+ * `instanceIds` gate deletes (matched by the instance element).
+ */
+export type AcceptedIds = {
+    sourceIds: ReadonlySet<string>;
+    instanceIds: ReadonlySet<string>;
+};
+/** source-element id -> user-edited values for that element's editable attributes. */
+export type CollisionOverrides = ReadonlyMap<string, Record<string, string>>;
+//# sourceMappingURL=decide.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/decide.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decide.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/decide.types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAChC,CAAA;AAED,sFAAsF;AACtF,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA"}

package/dist/v2019C1/extensions/lifecycle/engine/diff.d.ts

@@ -0,0 +1,30 @@
+import { DiffReport } from './diff.types';
+import { Config } from '../../../config';
+import { AnyRefOrRecord } from '@dialecte/core';
+import type * as Core from '@dialecte/core';
+/**
+ * Engine diff (ENGINE.md §3): compares an (updated) template subtree against the
+ * existing instance, matched by `templateUuid` (= the source element's `uuid`),
+ * and produces a structured `DiffReport`. This is the read-only "project then
+ * diff" report — the same-space comparison the apply/reconcile step consumes.
+ *
+ * Classification (fast vs full): a missing instance = first-time instantiate =
+ * fast (headless); an existing instance with any change = full (needs decisions).
+ * Deliberately scoped: one subtree, matched by `templateUuid`, no reference
+ * reconciliation or multi-instance disambiguation.
+ */
+export declare function diff(params: {
+    sourceQuery: Core.Query<Config>;
+    targetQuery: Core.Query<Config>;
+    sourceRootRef: AnyRefOrRecord;
+    /** Omit (or pass a ref that resolves to nothing) for a first-time instantiate. */
+    instanceRootRef?: AnyRefOrRecord;
+}): Promise<DiffReport>;
+/**
+ * Combine several reports into one (e.g. an ASD's application-layer report plus
+ * one per composed function). `root` keeps the first report's tree; `groups` is
+ * the concatenation (the full-track decision surface); `summary` sums; and
+ * `needsDecisions` is true if any part needs a decision.
+ */
+export declare function mergeReports(reports: [DiffReport, ...DiffReport[]]): DiffReport;
+//# sourceMappingURL=diff.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/diff.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAA6B,UAAU,EAAe,MAAM,cAAc,CAAA;AACtF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,gBAAgB,CAAA;AAKnE;;;;;;;;;;GAUG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IAClC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,aAAa,EAAE,cAAc,CAAA;IAC7B,kFAAkF;IAClF,eAAe,CAAC,EAAE,cAAc,CAAA;CAChC,GAAG,OAAO,CAAC,UAAU,CAAC,CA0CtB;AA+HD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE,GAAG,UAAU,EAAE,CAAC,GAAG,UAAU,CAmB/E"}

package/dist/v2019C1/extensions/lifecycle/engine/diff.types.d.ts

@@ -0,0 +1,121 @@
+import { EditableAttribute } from '../constraints';
+import { AnyRefOrRecord } from '@dialecte/core';
+/** How a diffed element changed between the (updated) template and the instance. */
+export type DiffChange = 'added' | 'removed' | 'modified' | 'unchanged';
+export type AttributeChange = {
+    name: string;
+    before?: string;
+    after?: string;
+};
+export type DiffNode = {
+    change: DiffChange;
+    tagName: string;
+    /** Source (template) element — present for `added` / `modified` / `unchanged`. */
+    sourceRef?: AnyRefOrRecord;
+    /** Instance element — present for `removed` / `modified` / `unchanged`. */
+    instanceRef?: AnyRefOrRecord;
+    /** Attribute deltas — present for `modified`. */
+    attributeChanges?: AttributeChange[];
+    children: DiffNode[];
+};
+export type DiffSummary = {
+    added: number;
+    removed: number;
+    modified: number;
+};
+/**
+ * An identity-locked placement collision on a decision group's primary: every field
+ * of the violated uniqueness constraint is identity (none editable), so the engine
+ * cannot differentiate a copy. `adoptTargetId` is the existing element the primary is
+ * identity-equal to (the reconcile target when the user chooses to adopt).
+ */
+export type GroupConflict = {
+    fields: string[];
+    adoptTargetId: string;
+};
+/**
+ * A decision unit for the full track (ENGINE.md §8, 07 §3.1). The user decides
+ * on a GROUP, never on an individual element.
+ *
+ * - `primary` is the recognizable change ("add Function X").
+ * - `companions` are its dependent changes that TRAVEL with it (structural
+ *   content now; reference-linked satellites / type-closure / provenance are a
+ *   follow-up). They are display-only — never independently toggled.
+ * - `dependsOn` are group ids this group requires (skip a parent → its
+ *   dependents are disabled). Empty in the first slice.
+ */
+export type DecisionGroup = {
+    /** Stable key of the primary; also the key in the `decisions` map. */
+    id: string;
+    change: Exclude<DiffChange, 'unchanged'>;
+    /** Coarse label (`"<change> <tag>"`); the UI enriches it via `extractElementTitle(primary.sourceRef ?? instanceRef)`. */
+    title: string;
+    primary: DiffNode;
+    companions: DiffNode[];
+    dependsOn: string[];
+    suggestedAction: 'accept';
+    /**
+     * The primary element's user-editable attributes with their edit mode
+     * (schema-derived via the attribute classifier), tagged at report time so the UI
+     * renders inputs directly from the report without re-deriving. Omitted until the
+     * report surface tags it.
+     */
+    editableAttributes?: EditableAttribute[];
+    /**
+     * Set at report time when placing the primary would violate a scoped-uniqueness
+     * constraint whose fields are ALL identity (non-editable) — the engine cannot make
+     * a distinct copy, so `instantiate` cannot duplicate it. The group then needs a
+     * decision: `skip` (leave the existing element) or `accept` = **adopt** (reconcile
+     * the template onto `adoptTargetId`, i.e. update that existing element in place).
+     * Omitted when there is no collision or the collision is resolvable (an editable
+     * field is bumped instead — see {@link EditableAttribute.conflict}).
+     */
+    conflict?: GroupConflict;
+    /**
+     * The id of the instance root this group belongs to, when several instances of one
+     * template are reported together (multi-instance). Lets the decision layer target a
+     * SUBSET of instances and lets apply partition groups per instance. Omitted for a
+     * first-time instantiate (no instance yet).
+     */
+    instanceScopeId?: string;
+    /**
+     * Human-readable title of the instance root (`extractElementTitle`), tagged at the
+     * report surface so a multi-instance UI can label each instance section (e.g. `Prot`
+     * vs `Prot_1`) without resolving the element itself. Omitted for a first-time
+     * instantiate.
+     */
+    instanceScopeTitle?: string;
+};
+export type DiffReport = {
+    root: DiffNode;
+    /**
+     * One root per instance in the report. A single diff carries `[root]`; a merged
+     * multi-instance report carries every instance's root (both layers for an ASD), so
+     * a UI can render each instance's full tree (unchanged context included) directly.
+     */
+    roots: DiffNode[];
+    /** The change tree folded into accept/skip units — the full-track surface. */
+    groups: DecisionGroup[];
+    /**
+     * `false` = fast track (apply headless): either a first-time instantiate (no
+     * existing instance) or nothing changed. `true` = full track: the instance
+     * exists and something changed, so the caller must resolve decisions.
+     */
+    needsDecisions: boolean;
+    summary: DiffSummary;
+};
+/**
+ * A user's choice on one decision group. Either a plain accept/skip, or an object
+ * carrying edited `values` for the primary's editable attributes (applied on accept —
+ * e.g. a user-chosen name that overrides the auto-resolved collision value).
+ */
+export type GroupDecision = 'accept' | 'skip' | {
+    action: 'accept' | 'skip';
+    values?: Record<string, string>;
+};
+/**
+ * The consumer's decisions, keyed by `DecisionGroup.id`. A group absent from the
+ * map takes its `suggestedAction` (accept). So an empty map = accept everything.
+ */
+export type DecisionMap = Map<string, GroupDecision>;
+//# sourceMappingURL=diff.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/diff.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/diff.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,oFAAoF;AACpF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;AAEvE,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/E,MAAM,MAAM,QAAQ,GAAG;IACtB,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,kFAAkF;IAClF,SAAS,CAAC,EAAE,cAAc,CAAA;IAC1B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,cAAc,CAAA;IAC5B,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAA;IACpC,QAAQ,EAAE,QAAQ,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9E;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG;IAC3B,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW,CAAC,CAAA;IACxC,yHAAyH;IACzH,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,QAAQ,CAAA;IACjB,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,eAAe,EAAE,QAAQ,CAAA;IACzB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,iBAAiB,EAAE,CAAA;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAA;IACd;;;;OAIG;IACH,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,8EAA8E;IAC9E,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB;;;;OAIG;IACH,cAAc,EAAE,OAAO,CAAA;IACvB,OAAO,EAAE,WAAW,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACtB,QAAQ,GACR,MAAM,GACN;IAAE,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAEjE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA"}

package/dist/v2019C1/extensions/lifecycle/engine/group.d.ts

@@ -0,0 +1,16 @@
+import { DecisionGroup, DiffNode } from './diff.types';
+/**
+ * Group stage (ENGINE.md §8, 07 §3.1): fold the `DiffNode` change tree into
+ * accept/skip decision units.
+ *
+ * v1 rule (structural): each **topmost** changed node (its ancestors are all
+ * unchanged) becomes a group `primary`; every changed node beneath it becomes a
+ * `companion` that travels with it (untoggleable). Separate top-level changed
+ * regions become separate groups.
+ *
+ * Deliberately deferred (follow-ups, kept out of the frozen shape's meaning):
+ * reference-linked companions (satellites via the ownership map + ref pairs),
+ * and `dependsOn` edges for nested-independent changes — both currently empty.
+ */
+export declare function groupChanges(root: DiffNode, instanceScopeId?: string): DecisionGroup[];
+//# sourceMappingURL=group.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,CAItF"}

package/dist/v2019C1/extensions/lifecycle/engine/index.d.ts

@@ -0,0 +1,8 @@
+export { diff, mergeReports } from './diff';
+export { groupChanges } from './group';
+export { reconcile } from './reconcile';
+export { acceptedRefIds, assertDecisionsCoherent, collisionOverrides, decisionAction, } from './decide';
+export { visibleAttributes } from './visible-attributes';
+export type { AcceptedIds, CollisionOverrides } from './decide.types';
+export type * from './diff.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EACN,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,GACd,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAExD,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACrE,mBAAmB,cAAc,CAAA"}

package/dist/v2019C1/extensions/lifecycle/engine/public.d.ts

@@ -0,0 +1,2 @@
+export type { AttributeChange, DecisionGroup, DecisionMap, DiffChange, DiffNode, DiffReport, DiffSummary, GroupConflict, GroupDecision, } from './diff.types';
+//# sourceMappingURL=public.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/public.ts"],"names":[],"mappings":"AAGA,YAAY,EACX,eAAe,EACf,aAAa,EACb,WAAW,EACX,UAAU,EACV,QAAQ,EACR,UAAU,EACV,WAAW,EACX,aAAa,EACb,aAAa,GACb,MAAM,cAAc,CAAA"}

package/dist/v2019C1/extensions/lifecycle/engine/reconcile.d.ts

@@ -0,0 +1,37 @@
+import { AcceptedIds, CollisionOverrides } from './decide.types';
+import { Config } from '../../../config';
+import { AnyRefOrRecord } from '@dialecte/core';
+import type * as Core from '@dialecte/core';
+/**
+ * Engine apply-core (ENGINE.md §3/§8): reconcile an updated template subtree
+ * (`sourceRootRef`) ONTO an existing instance (`instanceRootRef`) instead of
+ * duplicating it. Elements match by `templateUuid` (= the source element's
+ * `uuid`, immutable across template versions):
+ *
+ *  - matched element    -> update its user-visible attributes in place
+ *  - new source element -> add its subtree under the matched parent
+ *    (`transplant.deep` + `writeIdentity` stamp)
+ *  - instance element whose template lineage no longer exists in the source
+ *    -> delete
+ *
+ * This is the "project then diff" apply half: because the instance is already
+ * in instance-space, comparing source (template) to instance is clean once
+ * identity + the project-owned `name` are excluded. Deliberately scoped: no
+ * reference reconciliation and no multi-instance anchor disambiguation yet.
+ */
+export declare function reconcile(tx: Core.Transaction<Config>, params: {
+    sourceQuery: Core.Query<Config>;
+    sourceRootRef: AnyRefOrRecord;
+    instanceRootRef: AnyRefOrRecord;
+    /**
+     * When present, only elements in these accepted record-id sets are written
+     * (full-track decision gating). Omit to apply every change (fast track).
+     */
+    accepted?: AcceptedIds;
+    /**
+     * User-edited values per source element id (full track). Applied to a added
+     * element before its placement collision is resolved. Omit for auto-resolve only.
+     */
+    overrides?: CollisionOverrides;
+}): Promise<void>;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/reconcile.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,gBAAgB,CAAA;AAKnE;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,SAAS,CAC9B,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,aAAa,EAAE,cAAc,CAAA;IAC7B,eAAe,EAAE,cAAc,CAAA;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAA;IACtB;;;OAGG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAC9B,GACC,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/v2019C1/extensions/lifecycle/engine/visible-attributes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The attributes that take part in the same-space content diff/reconcile:
+ * everything except identity (`uuid`/`templateUuid`/`originUuid`), the
+ * project-owned `name`, and reference attributes.
+ */
+export declare function visibleAttributes(attributes: Record<string, string>): Record<string, string>;
+//# sourceMappingURL=visible-attributes.d.ts.map

package/dist/v2019C1/extensions/lifecycle/engine/visible-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visible-attributes.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/engine/visible-attributes.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO5F"}

package/dist/v2019C1/extensions/lifecycle/extract/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transaction';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/lifecycle/extract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/extract/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/v2019C1/extensions/{extraction/transaction/recipes/asd/to-asd.d.ts → lifecycle/extract/transaction/asd.d.ts}

@@ -1,10 +1,10 @@
-import { Scl, Config } from '../../../../../config';
+import { Scl, Config } from '../../../../config';
 import type * as Core from '@dialecte/core';
-export declare function toAsd(tx: Core.Transaction<Config>, params: {
+export declare function asd(tx: Core.Transaction<Config>, params: {
     sourceQuery: Core.Query<Config>;
     applicationRef: Scl.Ref<'Application'>;
     tool: Scl.AttributesValueObjectOf<'Header'>['toolID'];
     who: Scl.AttributesValueObjectOf<'Hitem'>['who'];
     nameStructure?: Scl.AttributesValueObjectOf<'Header'>['nameStructure'];
 }): Promise<void>;
-//# sourceMappingURL=to-asd.d.ts.map
+//# sourceMappingURL=asd.d.ts.map

package/dist/v2019C1/extensions/lifecycle/extract/transaction/asd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asd.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/asd.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,wBAAsB,GAAG,CACxB,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,cAAc,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IACtC,IAAI,EAAE,GAAG,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAA;IACrD,GAAG,EAAE,GAAG,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;IAChD,aAAa,CAAC,EAAE,GAAG,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC,CAAA;CACtE,GACC,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/v2019C1/extensions/{extraction/transaction/recipes/shared → lifecycle/extract/transaction}/ensure-substation-structure.d.ts

@@ -1,4 +1,4 @@
-import { Scl, Config } from '../../../../../config';
+import { Scl, Config } from '../../../../config';
 import type * as Core from '@dialecte/core';
 export declare function ensureSubstationTemplateStructure(tx: Core.Transaction<Config>): Promise<{
     Substation: Scl.RawRecord<'Substation'>;

package/dist/v2019C1/extensions/lifecycle/extract/transaction/ensure-substation-structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-substation-structure.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/ensure-substation-structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,wBAAsB,iCAAiC,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IAC9F,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;IACvC,YAAY,EAAE,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;IAC3C,GAAG,EAAE,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;CACzB,CAAC,CAuBD"}

package/dist/v2019C1/extensions/{extraction/transaction/recipes/fsd/to-fsd.d.ts → lifecycle/extract/transaction/fsd.d.ts}

@@ -1,10 +1,10 @@
-import { Scl, Config } from '../../../../../config';
+import { Scl, Config } from '../../../../config';
 import type * as Core from '@dialecte/core';
-export declare function toFsd(tx: Core.Transaction<Config>, params: {
+export declare function fsd(tx: Core.Transaction<Config>, params: {
     sourceQuery: Core.Query<Config>;
     functionRef: Scl.Ref<'Function'> | Scl.Ref<'SubFunction'>;
     tool: Scl.AttributesValueObjectOf<'Header'>['toolID'];
     who: Scl.AttributesValueObjectOf<'Hitem'>['who'];
     nameStructure?: Scl.AttributesValueObjectOf<'Header'>['nameStructure'];
 }): Promise<void>;
-//# sourceMappingURL=to-fsd.d.ts.map
+//# sourceMappingURL=fsd.d.ts.map

package/dist/v2019C1/extensions/lifecycle/extract/transaction/fsd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fsd.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/fsd.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,wBAAsB,GAAG,CACxB,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IACzD,IAAI,EAAE,GAAG,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAA;IACrD,GAAG,EAAE,GAAG,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;IAChD,aAAa,CAAC,EAAE,GAAG,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC,CAAA;CACtE,GACC,OAAO,CAAC,IAAI,CAAC,CAyCf"}

package/dist/v2019C1/extensions/lifecycle/extract/transaction/index.d.ts

@@ -0,0 +1,4 @@
+export { ensureSubstationTemplateStructure } from './ensure-substation-structure';
+export { asd } from './asd';
+export { fsd } from './fsd';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/lifecycle/extract/transaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,+BAA+B,CAAA;AACjF,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA"}

package/dist/v2019C1/extensions/{extraction/transaction/recipes/fsd → lifecycle/extract/transaction}/omit.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '../../../../../config';
+import { Config } from '../../../../config';
 import { OmitEntry } from '@dialecte/core';
 export declare const FSD_OMIT: OmitEntry<Config>[];
 //# sourceMappingURL=omit.d.ts.map

package/dist/v2019C1/extensions/lifecycle/extract/transaction/omit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/omit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,eAAO,MAAM,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,EAUvC,CAAA"}

package/dist/v2019C1/extensions/{extraction/transaction/recipes/shared → lifecycle/extract/transaction}/post-extraction-cleanup.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '../../../../../config';
+import { Config } from '../../../../config';
 import type * as Core from '@dialecte/core';
 /**
  * Universal post-extraction cleanup run after cloning records into a target DB.

package/dist/v2019C1/extensions/lifecycle/extract/transaction/post-extraction-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-extraction-cleanup.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/lifecycle/extract/transaction/post-extraction-cleanup.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvF"}

package/dist/v2019C1/extensions/lifecycle/index.d.ts

@@ -0,0 +1,44 @@
+import { apply } from './apply';
+import { report } from './report';
+import { deep } from './transplant';
+import * as extractTransaction from './extract';
+import * as instantiateTransaction from './instantiate';
+import * as updateTransaction from './update';
+/**
+ * SCL content lifecycle — the verbs that move template/instance content across
+ * documents, grouped under a single `lifecycle` module so consumers get one
+ * stable, discoverable surface: `tx.lifecycle.<verb>.<recipe>` /
+ * `query.lifecycle.<verb>.<recipe>`.
+ *
+ * - `extract`     — pull an element out into a template FSD/ASD
+ *                   (`tx.lifecycle.extract.fsd` / `.asd` /
+ *                   `.ensureSubstationTemplateStructure`).
+ * - `instantiate` — instantiate template content into a project
+ *                   (`tx.lifecycle.instantiate.fsd` / `.asd`).
+ * - `transplant`  — generic clone engine (`tx.lifecycle.transplant.deep`).
+ * - `update`      — instantiate-or-reconcile a project against a newer template
+ *                   (`tx.lifecycle.update.fsd` / `.asd` apply the change).
+ * - `report`      — read-only classify: `query.lifecycle.report({ verb,
+ *                   sourceQuery, ref, anchor })` returns a `DiffReport`
+ *                   (fast/full classification) — nothing is written.
+ *
+ * Two-track surface (verb-agnostic, ENGINE.md §6): `query.lifecycle.report(...)`
+ * classifies, then `tx.lifecycle.apply(tx, { ..., report })` applies the fast
+ * track headless (full track returns the report for decision review — nothing is
+ * written until decisions come back).
+ */
+export declare const lifecycle: {
+    query: {
+        report: typeof report;
+    };
+    transaction: {
+        extract: typeof extractTransaction;
+        instantiate: typeof instantiateTransaction;
+        transplant: {
+            deep: typeof deep;
+        };
+        update: typeof updateTransaction;
+        apply: typeof apply;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/lifecycle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/extensions/lifecycle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,KAAK,kBAAkB,MAAM,WAAW,CAAA;AAC/C,OAAO,KAAK,sBAAsB,MAAM,eAAe,CAAA;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,iBAAiB,MAAM,UAAU,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;CAWrB,CAAA"}

package/dist/v2019C1/extensions/lifecycle/instance/composed-functions.d.ts

@@ -0,0 +1,10 @@
+import { Scl, Config } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * The `uuid`s of every Function an Application composes — collected from the
+ * `functionUuid` of each `FunctionRef` in the Application subtree. Shared by the
+ * `update.fromAsd` apply cascade and the `reportAsd` report cascade so both walk
+ * the composed-function set identically.
+ */
+export declare function collectComposedFunctionUuids(sourceQuery: Core.Query<Config>, applicationRef: Scl.Ref<'Application'>): Promise<Set<string>>;
+//# sourceMappingURL=composed-functions.d.ts.map

package/dist/v2019C1/extensions/lifecycle/instance/composed-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed-functions.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/instance/composed-functions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAG3C;;;;;GAKG;AACH,wBAAsB,4BAA4B,CACjD,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,GACpC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAKtB"}