@dialecte/scl 0.3.1 → 0.3.3

package/dist/v2019C1/constants/index.d.ts

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

package/dist/v2019C1/constants/index.d.ts.map

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

package/dist/v2019C1/{extensions/reference/constants/pairs.d.ts → constants/reference-pairs.d.ts}

@@ -1,13 +1,3 @@
-import { RESOLUTION_TYPE } from './resolution-types';
-/**
- * Complete mapping of elements that have path/name -> UUID reference pairs.
- *
- * Each entry maps an element tag to its reference attribute pairs where:
- * - `path`: the attribute holding a pathname or name reference
- * - `uuid`: the corresponding UUID attribute that identifies the same target
- * - `target`: the element tag(s) the UUID resolves to
- * - `companions`: attributes that must/may be set when the UUID is used
- */
 export declare const UUID_REFERENCE_PAIRS: {
     readonly AllocationRoleRef: readonly [{
         readonly attribute: {
@@ -321,7 +311,7 @@ export declare const UUID_REFERENCE_PAIRS: {
             readonly uuid: "elementUuid";
         };
         readonly resolution: "unsupported";
-        readonly target: readonly ["LNode", "Function", "SubFunction", "EqFunction", "EqSubFunction"];
+        readonly target: readonly ["AccessControl", "AccessPoint", "Address", "AllocationRole", "AllocationRoleRef", "AnalogueWiringParameters", "AnalogueWiringParametersRef", "Application", "ApplicationSclRef", "Association", "Authentication", "BDA", "Bay", "BayType", "BehaviorDescription", "BehaviorDescriptionRef", "BehaviorReference", "BinaryWiringParameters", "BinaryWiringParametersRef", "BitRate", "CheckoutID", "ClientLN", "ClientServices", "CommProt", "Communication", "CommunicationServiceSpecifications", "ConductingEquipment", "ConfDataSet", "ConfLNs", "ConfLdName", "ConfLogControl", "ConfReportControl", "ConfSG", "ConfSigRef", "ConnectedAP", "ConnectivityNode", "ControlRef", "ControllingLNode", "DA", "DAI", "DAS", "DAType", "DO", "DOI", "DOS", "DOType", "DataObjectDirectory", "DataSet", "DataSetDirectory", "DataTypeTemplates", "DynAssociation", "DynDataSet", "EnumType", "EnumVal", "EqFunction", "EqSubFunction", "ExtCtrl", "ExtRef", "FCDA", "FileHandling", "Function", "FunctionCatRef", "FunctionCategory", "FunctionCategoryRef", "FunctionRef", "FunctionRole", "FunctionRoleContent", "FunctionSclRef", "FunctionTemplate", "FunctionalSubVariant", "FunctionalVariant", "FunctionalVariantGroup", "FunctionalVariantRef", "GOOSE", "GOOSEMcSecurity", "GOOSESecurity", "GSE", "GSEControl", "GSEDir", "GSESettings", "GSSE", "GeneralEquipment", "GetCBValues", "GetDataObjectDefinition", "GetDataSetValue", "GetDirectory", "GooseParameters", "GooseParametersRef", "Header", "History", "Hitem", "IED", "IEDName", "IEDSourceFiles", "InputVar", "InputVarRef", "Inputs", "IssuerName", "KDC", "L2CommParameters", "L3IPv4CommParameters", "L3IPv6CommParameters", "LDevice", "LN", "LN0", "LNode", "LNodeDataRef", "LNodeInputRef", "LNodeInputs", "LNodeOutputRef", "LNodeOutputs", "LNodeSpecNaming", "LNodeType", "Label", "Labels", "Line", "Log", "LogControl", "LogParameters", "LogParametersRef", "LogSettings", "MaxTime", "McSecurity", "MinRequestedSCDFile", "MinRequestedSCDFiles", "MinTime", "MultiAPPerSubNet", "NeutralPoint", "OptFields", "OutputVar", "OutputVarRef", "Outputs", "P", "PhysConn", "PowerSystemRelation", "PowerSystemRelationRef", "PowerSystemRelations", "PowerTransformer", "Private", "Process", "ProcessEcho", "ProcessResource", "ProcessResourceRef", "ProcessResources", "Project", "ProjectProcessReference", "ProtNs", "Protocol", "ReadWrite", "RedProt", "ReportControl", "ReportParameters", "ReportParametersRef", "ReportSettings", "Resource", "RptEnabled", "SCL", "SCSM", "SDI", "SDO", "SDS", "SGEdit", "SMV", "SMVParameters", "SMVParametersRef", "SMVSecurity", "SMVSettings", "SMVsc", "SVMcSecurity", "SampledValueControl", "SamplesPerSec", "SclFileReference", "SecPerSamples", "Security", "Server", "ServerAt", "ServiceSpecifications", "Services", "SetDataSetValue", "SettingControl", "SettingGroups", "SignalRole", "SmpRate", "SmvOpts", "SourceFiles", "SourceRef", "SubCategory", "SubCheckoutID", "SubEquipment", "SubFunction", "SubFunctionTemplate", "SubNetwork", "Subject", "SubscriberLNode", "Substation", "SupSubscription", "TapChanger", "Terminal", "Text", "TimeSyncProt", "TimerActivatedControl", "TransformerWinding", "TrgOps", "Val", "ValueHandling", "Variable", "VariableApplyTo", "VariableRef", "Voltage", "VoltageLevel"];
         readonly companions: readonly [{
             readonly name: "doName";
             readonly required: false;
@@ -340,5 +330,4 @@ export declare const UUID_REFERENCE_PAIRS: {
         readonly companions: readonly [];
     }];
 };
-export { RESOLUTION_TYPE };
-//# sourceMappingURL=pairs.d.ts.map
+//# sourceMappingURL=reference-pairs.d.ts.map

package/dist/v2019C1/constants/reference-pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-pairs.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/constants/reference-pairs.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoSvB,CAAA"}

package/dist/v2019C1/extensions/clean-up/transaction/orphan-lnode-bindings.d.ts

@@ -4,7 +4,9 @@ import type * as Core from '@dialecte/core';
  * Resets LNode IED bindings when the referenced IED is absent from the target DB.
  *
  * Logic per LNode:
- * - iedName is 'None' or empty → skip (already unbound)
+ * - iedName is 'None', empty, or absent → normalize the unbound marker to an
+ *   explicit iedName='None' (the store is faithful, so an omitted iedName is not
+ *   auto-stamped on import; the cleanup makes the canonical marker explicit)
  * - IED with matching name found → skip (binding valid)
  * - IED absent + LNodeSpecNaming child exists → restore lnClass/lnInst/prefix
  *   from spec naming, clear iedName/ldInst/lnUuid, reset spec naming sIedName/sLdInst

package/dist/v2019C1/extensions/clean-up/transaction/orphan-lnode-bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orphan-lnode-bindings.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/clean-up/transaction/orphan-lnode-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAe7E"}
+{"version":3,"file":"orphan-lnode-bindings.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/clean-up/transaction/orphan-lnode-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAO,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB7E"}

package/dist/v2019C1/extensions/clean-up/transaction/orphan-uuid-refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orphan-uuid-refs.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/clean-up/transaction/orphan-uuid-refs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAO,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyChF"}
+{"version":3,"file":"orphan-uuid-refs.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/clean-up/transaction/orphan-uuid-refs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAO,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAyChF"}

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

@@ -0,0 +1,5 @@
+import * as identityTransaction from './transaction';
+export declare const identity: {
+    transaction: typeof identityTransaction;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/extensions/identity/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,mBAAmB,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,QAAQ;;CAEpB,CAAA"}

package/dist/v2019C1/extensions/identity/transaction/index.d.ts

@@ -0,0 +1,3 @@
+export { writeIdentity } from './write-identity';
+export type { IdentityMode } from './write-identity.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2019C1/extensions/identity/transaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/identity/transaction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/v2019C1/extensions/identity/transaction/write-identity.d.ts

@@ -0,0 +1,21 @@
+import { IdentityMode } from './write-identity.types';
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Writes instance-lineage identity onto the target records of a clone, driven by
+ * the clone mappings (each carries the source record's original attributes, so
+ * no cross-document query is needed).
+ *
+ * - `stamp-template` (instantiate / update): rotate lineage so the source
+ *   identity becomes the template lineage of a fresh instance —
+ *   `templateUuid <- source.uuid` and `originUuid <- source.templateUuid` (only
+ *   when the origin slot is free and the element type carries a two-level
+ *   lineage). The instance `uuid` is already fresh from `deepClone`.
+ * - `strip` (extract): drop `templateUuid` and `originUuid`, leaving a fresh template.
+ * - `keep` (fork): leave lineage untouched.
+ */
+export declare function writeIdentity(tx: Core.Transaction<Config>, params: {
+    mappings: readonly Scl.CloneMapping[];
+    mode: IdentityMode;
+}): Promise<void>;
+//# sourceMappingURL=write-identity.d.ts.map

package/dist/v2019C1/extensions/identity/transaction/write-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-identity.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/identity/transaction/write-identity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAClC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,QAAQ,EAAE,SAAS,GAAG,CAAC,YAAY,EAAE,CAAA;IACrC,IAAI,EAAE,YAAY,CAAA;CAClB,GACC,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/v2019C1/extensions/identity/transaction/write-identity.types.d.ts

@@ -0,0 +1,3 @@
+/** How to write instance-lineage identity onto the target records of a clone. */
+export type IdentityMode = 'strip' | 'stamp-template' | 'keep';
+//# sourceMappingURL=write-identity.types.d.ts.map

package/dist/v2019C1/extensions/identity/transaction/write-identity.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-identity.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/identity/transaction/write-identity.types.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAAA"}

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

@@ -6,13 +6,27 @@ export declare const SCL_EXTENSION_MODULES: {
         query: typeof import("./data-model/query");
         transaction: typeof import("./data-model/transaction");
     };
-    extraction: {
-        transaction: typeof import("./extraction/transaction");
-    };
     history: {
         query: typeof import("./history/query");
         transaction: typeof import("./history/transaction");
     };
+    identity: {
+        transaction: typeof import("./identity/transaction");
+    };
+    lifecycle: {
+        query: {
+            report: typeof import('./lifecycle/report').report;
+        };
+        transaction: {
+            extract: typeof import("./lifecycle/extract");
+            instantiate: typeof import("./lifecycle/instantiate");
+            transplant: {
+                deep: typeof import('./lifecycle/transplant').deep;
+            };
+            update: typeof import("./lifecycle/update");
+            apply: typeof import('./lifecycle/apply').apply;
+        };
+    };
     reference: {
         query: typeof import("./reference/query");
         transaction: typeof import("./reference/transaction");

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/extensions/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAQjC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/extensions/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASjC,CAAA"}

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

@@ -0,0 +1,29 @@
+import { ApplyResult } from './apply.types';
+import { Config } from '../../../config';
+import { LifecycleApplyParams } from '../contract.types';
+import type * as Core from '@dialecte/core';
+/**
+ * `tx.lifecycle.apply` — the generic write surface (ENGINE.md §4/§6, 07 §4).
+ *
+ * The consumer classifies first (`query.lifecycle.report`) and passes the
+ * `report` in. The report + `decisions` gate what is written:
+ *
+ *  - **fast** (`needsDecisions === false`): first-time instantiate or a
+ *    conflict-free change → apply headless (delegate to the per-layer update
+ *    verb with no gate). When `decisions` are still supplied, their user value
+ *    edits (editable attributes) are honored; there is simply no accept/skip gate.
+ *  - **full, not decided** (`needsDecisions === true`, no `decisions`): a human
+ *    must resolve decisions first → nothing is written; the report is returned
+ *    unchanged so the caller can drive the review flow.
+ *  - **full, decided** (`decisions` present): apply ONLY the accepted groups and
+ *    their companions (the gate is passed to the update verb, which threads it
+ *    through reconcile and the ASD cascade). A group absent from the map defaults
+ *    to accept. The engine rejects a decision set that accepts a group whose
+ *    `dependsOn` parent is skipped (07 §4).
+ *
+ * Returns `{ report, instances }` — the effective report plus the instance roots
+ * the write produced/reconciled. Run inside `doc.prepare(tx => tx.lifecycle.apply(...))`
+ * for a previewable, reversible dry-run.
+ */
+export declare function apply(tx: Core.Transaction<Config>, params: LifecycleApplyParams): Promise<ApplyResult>;
+//# sourceMappingURL=apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/apply/apply.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EACX,oBAAoB,EAEpB,MAAM,+CAA+C,CAAA;AAEtD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,KAAK,CAC1B,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE,oBAAoB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAetB"}

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

@@ -0,0 +1,26 @@
+import { Scl } from '../../../config';
+import { DiffReport } from '../engine/diff.types';
+/**
+ * The instance roots a lifecycle write produced or reconciled, discriminated by
+ * verb. Flat arrays are scenario-honest: `instantiate` yields exactly one root
+ * set; `update` may reconcile several instances of one template (all listed).
+ * The "not decided yet" apply track yields empty arrays.
+ */
+export type AppliedInstances = {
+    verb: 'fsd';
+    functions: (Scl.Ref<'Function'> | Scl.Ref<'SubFunction'>)[];
+} | {
+    verb: 'asd';
+    applications: Scl.Ref<'Application'>[];
+    functions: (Scl.Ref<'Function'> | Scl.Ref<'SubFunction'>)[];
+};
+/**
+ * The result of `tx.lifecycle.apply`: the effective `report` plus the instance
+ * roots the write produced/reconciled (`instances`). Consumers act on the roots
+ * in the SAME transaction (name, wire, select, chain) without re-deriving them.
+ */
+export type ApplyResult = {
+    report: DiffReport;
+    instances: AppliedInstances;
+};
+//# sourceMappingURL=apply.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/apply/apply.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAA;AAElF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACzB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,EAAE,CAAA;CAAE,GAC5E;IACA,IAAI,EAAE,KAAK,CAAA;IACX,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAA;IACtC,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,EAAE,CAAA;CAC1D,CAAA;AAEJ;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,gBAAgB,CAAA;CAC3B,CAAA"}

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

@@ -0,0 +1,3 @@
+export { apply } from './apply';
+export type { AppliedInstances, ApplyResult } from './apply.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/apply/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.constants.d.ts

@@ -0,0 +1,5 @@
+/** Lineage attributes — identity backbone, never user-editable. */
+export declare const LINEAGE: Set<string>;
+/** The classifier modes the UI may expose as editable inputs (no identity/reference side effect). */
+export declare const EDITABLE_MODES: readonly ["rename", "free"];
+//# sourceMappingURL=classify-attribute.constants.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-attribute.constants.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/classify-attribute.constants.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,OAAO,aAAkD,CAAA;AAEtE,qGAAqG;AACrG,eAAO,MAAM,cAAc,6BAA8B,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.d.ts

@@ -0,0 +1,25 @@
+import { EDITABLE_MODES } from './classify-attribute.constants';
+import { AttributeEditability, EditableAttribute } from './classify-attribute.types';
+/**
+ * Classify how the UI may treat an attribute of an element during a lifecycle
+ * transaction (schema-derived, no hardcoded element rules):
+ *
+ *  - lineage (`uuid`/`templateUuid`/`originUuid`) -> `identity`;
+ *  - a reference path/uuid attribute (from `UUID_REFERENCE_PAIRS`) -> `reference`
+ *    (system-owned, remapped automatically);
+ *  - `name` -> `rename` (the mutable label; changing it triggers a managed ref-path
+ *    rebuild — 61850-6 §8.5.6: the uuid is fixed, the name evolves);
+ *  - any other path-contributing attribute (lnClass, prefix, inst, …) or scoped-key
+ *    field -> `identity` (intrinsic; changing it is a delete+create, not an edit);
+ *  - everything else -> `free`.
+ */
+export declare function classifyAttribute(tag: string, attr: string): AttributeEditability;
+/** Whether a classified attribute is user-editable (`rename` or `free`). */
+export declare function isEditableMode(mode: AttributeEditability): mode is (typeof EDITABLE_MODES)[number];
+/**
+ * The attributes of `tag` the UI may edit with no harmful side effect, each with its
+ * edit mode. `rename` triggers a managed remap; `free` has no side effect. Identity
+ * and reference attributes are omitted (nothing to show as editable).
+ */
+export declare function editableAttributes(tag: string): EditableAttribute[];
+//# sourceMappingURL=classify-attribute.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-attribute.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/classify-attribute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAW,MAAM,gCAAgC,CAAA;AAOxE,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAEzF;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,CAMjF;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAC7B,IAAI,EAAE,oBAAoB,GACxB,IAAI,IAAI,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAQnE"}

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.types.d.ts

@@ -0,0 +1,23 @@
+/** How the UI may treat an attribute of an element during a lifecycle transaction. */
+export type AttributeEditability = 
+/** Identity/lineage — never user-editable (uuid, lnClass, and other scoped-key fields). */
+'identity'
+/** A reference (path/uuid pair) — system-owned, remapped automatically. */
+ | 'reference'
+/** The mutable label (`name`) — editable; changing it triggers a managed ref-path rebuild. */
+ | 'rename'
+/** Freely editable — no reference/identity side effect (desc, value, …). */
+ | 'free';
+/** An attribute the UI may edit, with its edit mode (from {@link AttributeEditability}). */
+export type EditableAttribute = {
+    attr: string;
+    mode: 'rename' | 'free';
+    /**
+     * Set at report time when placing this element would collide on this field and the
+     * engine auto-resolved it. `suggestedValue` is the collision-free value the engine
+     * proposes (the user may keep or override it).
+     */
+    conflict?: boolean;
+    suggestedValue?: string;
+};
+//# sourceMappingURL=classify-attribute.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/classify-attribute.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-attribute.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/classify-attribute.types.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,MAAM,oBAAoB;AAC/B,2FAA2F;AACzF,UAAU;AACZ,2EAA2E;GACzE,WAAW;AACb,8FAA8F;GAC5F,QAAQ;AACV,4EAA4E;GAC1E,MAAM,CAAA;AAET,4FAA4F;AAC5F,MAAM,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAA;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.d.ts

@@ -0,0 +1,21 @@
+import { ConstraintViolation } from './find-constraint-violation.types';
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Detect whether placing a `childTag` element with the given `candidate` attribute
+ * values under `parentRef` would violate a scoped-uniqueness constraint declared on
+ * the parent (e.g. two children with the same `name` under one Bay). Schema-driven:
+ * reads the parent's `constraints` and compares the candidate's key fields against
+ * the existing children the constraint selects.
+ *
+ * Returns the first violation found, or `null` if the candidate is unique.
+ * `excludeId` skips a specific existing child (e.g. the element itself when
+ * re-checking after a rename).
+ */
+export declare function findConstraintViolation(query: Core.Query<Config>, params: {
+    parentRef: Scl.Ref<Scl.ElementsOf>;
+    childTag: string;
+    candidate: Record<string, string | undefined>;
+    excludeId?: string;
+}): Promise<ConstraintViolation | null>;
+//# sourceMappingURL=find-constraint-violation.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-constraint-violation.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAoB,MAAM,mCAAmC,CAAA;AAC9F,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC5C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE;IACP,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,GACC,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA+BrC"}

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.types.d.ts

@@ -0,0 +1,26 @@
+/** A scoped-uniqueness constraint declared on a parent element (from the schema). */
+export type SchemaConstraint = {
+    kind: string;
+    name: string;
+    selector?: {
+        steps?: {
+            kind: string;
+            value?: string;
+        }[];
+    }[];
+    fields?: {
+        target?: {
+            value?: string;
+        };
+    }[];
+};
+/** A detected violation: the constraint broken and the existing child it collides with. */
+export type ConstraintViolation = {
+    /** The violated constraint's name (e.g. `uniqueChildNameInBay`). */
+    constraint: string;
+    /** The key fields the constraint compares (e.g. `['name']`). */
+    fields: string[];
+    /** The id of the existing sibling the candidate collides with. */
+    offendingId: string;
+};
+//# sourceMappingURL=find-constraint-violation.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-constraint-violation.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/find-constraint-violation.types.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,EAAE,CAAA;IAC3D,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAA;CAC1C,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,mBAAmB,GAAG;IACjC,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,gEAAgE;IAChE,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violations.d.ts

@@ -0,0 +1,17 @@
+import { ConstraintViolation } from './find-constraint-violation.types';
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Validate a whole subtree against its parent context: walk the tree rooted at
+ * `ref` and, for every element, check whether it violates a scoped-uniqueness
+ * constraint declared on its parent (via {@link findConstraintViolation}). Returns
+ * every violation found — the "check globally" seed of a future validation feature.
+ *
+ * The root itself is checked only when `parentRef` is given (its parent lives
+ * outside the subtree); internal nodes are checked against their in-tree parent.
+ */
+export declare function findConstraintViolations(query: Core.Query<Config>, params: {
+    ref: Scl.Ref<Scl.ElementsOf>;
+    parentRef?: Scl.Ref<Scl.ElementsOf>;
+}): Promise<ConstraintViolation[]>;
+//# sourceMappingURL=find-constraint-violations.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/find-constraint-violations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-constraint-violations.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/find-constraint-violations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAG3C;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE;IAAE,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;CAAE,GAC3E,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAQhC"}

package/dist/v2019C1/extensions/lifecycle/constraints/identity-fields.d.ts

@@ -0,0 +1,2 @@
+export declare function getIdentityFields(tag: string): ReadonlySet<string>;
+//# sourceMappingURL=identity-fields.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/identity-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-fields.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/identity-fields.ts"],"names":[],"mappings":"AAaA,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAUlE"}

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

@@ -0,0 +1,12 @@
+export { classifyAttribute, editableAttributes, isEditableMode } from './classify-attribute';
+export { EDITABLE_MODES } from './classify-attribute.constants';
+export { getIdentityFields } from './identity-fields';
+export { findConstraintViolation } from './find-constraint-violation';
+export { findConstraintViolations } from './find-constraint-violations';
+export { resolveUniqueValue } from './resolve-unique-value';
+export { resolvePlacementCollision } from './resolve-placement-collision';
+export type { AttributeEditability, EditableAttribute } from './classify-attribute.types';
+export type { ConstraintViolation, SchemaConstraint } from './find-constraint-violation.types';
+export type { CollisionDecorator } from './resolve-unique-value.types';
+export type { PlacementResolution } from './resolve-placement-collision.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC5F,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAA;AAEzE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AACzF,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAC9F,YAAY,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACtE,YAAY,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA"}

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

@@ -0,0 +1,2 @@
+export type { AttributeEditability, EditableAttribute } from './classify-attribute.types';
+//# sourceMappingURL=public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/public.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.d.ts

@@ -0,0 +1,29 @@
+import { PlacementResolution } from './resolve-placement-collision.types';
+import { CollisionDecorator } from './resolve-unique-value.types';
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Validate a just-placed element against its parent context and resolve a scoped-
+ * uniqueness collision GENERICALLY over whichever key field is EDITABLE:
+ *
+ *  1. detect a violation from the parent (`findConstraintViolation`);
+ *  2. if the violated key includes an editable field (`rename`/`free` per
+ *     `classifyAttribute`), bump it to the first free value (`resolveUniqueValue`)
+ *     and apply it — the after-updated hook then rebuilds any ref paths that
+ *     traverse it;
+ *  3. if the violated key is entirely IDENTITY (e.g. an LNode lnClass/lnInst tuple),
+ *     it is NOT auto-resolvable (that would be a delete+create) — reported as
+ *     `unresolvable` for the future validation/conflict surface.
+ *
+ * This is the auto-resolution (default fallback) half; a full-track consumer can
+ * instead supply `overrides` (user-edited values for editable attributes). Those are
+ * applied first, then uniqueness is re-ensured on the key field — so a user-typed name
+ * that itself collides is still bumped to a free value.
+ */
+export declare function resolvePlacementCollision(tx: Core.Transaction<Config>, params: {
+    ref: Scl.Ref<Scl.ElementsOf>;
+    parentRef?: Scl.Ref<Scl.ElementsOf>;
+    decorate?: CollisionDecorator;
+    overrides?: Record<string, string>;
+}): Promise<PlacementResolution>;
+//# sourceMappingURL=resolve-placement-collision.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-placement-collision.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAC9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,yBAAyB,CAC9C,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE;IACP,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,GACC,OAAO,CAAC,mBAAmB,CAAC,CA6C9B"}

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.types.d.ts

@@ -0,0 +1,20 @@
+import { ConstraintViolation } from './find-constraint-violation.types';
+/** The outcome of resolving a placement collision. */
+export type PlacementResolution = 
+/** No constraint was violated. */
+{
+    status: 'ok';
+}
+/** A violation auto-resolved by bumping an editable field to a free value. */
+ | {
+    status: 'resolved';
+    attr: string;
+    from: string;
+    to: string;
+}
+/** A violation whose key is entirely identity — not auto-resolvable here. */
+ | {
+    status: 'unresolvable';
+    violation: ConstraintViolation;
+};
+//# sourceMappingURL=resolve-placement-collision.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-placement-collision.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/resolve-placement-collision.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAE5E,sDAAsD;AACtD,MAAM,MAAM,mBAAmB;AAC9B,kCAAkC;AAChC;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE;AAClB,8EAA8E;GAC5E;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE;AAChE,6EAA6E;GAC3E;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,mBAAmB,CAAA;CAAE,CAAA"}

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.d.ts

@@ -0,0 +1,23 @@
+import { CollisionDecorator } from './resolve-unique-value.types';
+import { Config, Scl } from '../../../config';
+import type * as Core from '@dialecte/core';
+/**
+ * Resolve a collision-free value for the editable attribute `attr` of an element
+ * being placed under `parentRef`, generic over `attr` (not hardcoded to `name`).
+ *
+ *  - candidate unique as-is -> returns its current `attr` value unchanged;
+ *  - otherwise proposes `${base}_${attempt}` (or a consumer-decorated variant) and
+ *    increments `attempt` until the whole candidate is collision-free.
+ *
+ * The engine owns uniqueness (the loop); the {@link CollisionDecorator} only shapes
+ * the scheme. `excludeId` skips the element itself when re-checking an in-place value.
+ */
+export declare function resolveUniqueValue(query: Core.Query<Config>, params: {
+    parentRef: Scl.Ref<Scl.ElementsOf>;
+    childTag: string;
+    candidate: Record<string, string | undefined>;
+    attr: string;
+    decorate?: CollisionDecorator;
+    excludeId?: string;
+}): Promise<string>;
+//# sourceMappingURL=resolve-unique-value.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-unique-value.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAI3C;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACvC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE;IACP,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,GACC,OAAO,CAAC,MAAM,CAAC,CAsBjB"}

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Consumer hook that shapes the collision-resolution naming scheme. Given the base
+ * value and the current attempt, returns a candidate value. The engine still owns
+ * uniqueness (it loops `attempt` until the candidate is collision-free), so a hook
+ * need not guarantee uniqueness — only the scheme (e.g. a domain affix).
+ *
+ * Default (no hook): `` `${base}_${attempt}` ``. A SET affix hook could return
+ * `` `${base}_Fn_${attempt}` ``.
+ */
+export type CollisionDecorator = (params: {
+    base: string;
+    attempt: number;
+    attr: string;
+    childTag: string;
+}) => string;
+//# sourceMappingURL=resolve-unique-value.types.d.ts.map

package/dist/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-unique-value.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/lifecycle/constraints/resolve-unique-value.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CAChB,KAAK,MAAM,CAAA"}

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"}