@beehexa/hexasync-template-model 2608.20.18 → 2608.20.32

package/dist/references.js

@@ -0,0 +1,368 @@
+/**
+ * Which properties name another component — measured, not assumed (Stories 3.4 and 3.7).
+ *
+ * This list was originally guessed from what the collections are called, and the guess was wrong
+ * in both directions. It is now derived from the corpus: every `*Id` / `*Ids` property in nine
+ * real projects was resolved against the effective graph and kept only if its values are actually
+ * component ids. The measured figures are recorded here because a list like this decays silently
+ * — a property added next year will not announce itself — and the next person needs to know how
+ * to re-derive it rather than how to guess again.
+ *
+ * Resolution rates, measured over real projects (hits / occurrences):
+ *
+ *   taskId            651/651  100%      metricId           0/651   0%
+ *   connectorId       413/413  100%      providerId          0/27   0%
+ *   connectionId      284/284  100%      columnIds           0/11   0%
+ *   entityId          115/115  100%      credentialId         0/5   0%
+ *   objectIds          90/90   100%      profileId            0/5   0%
+ *   targetId           59/59   100%      systemId             0/4   0%
+ *   fromConnectionId   54/54   100%      integrationAppId     0/4   0%
+ *   objectId           50/50   100%      itemIds              0/3   0%
+ *   object_id          13/13   100%
+ *   pusherId            5/5    100%
+ *   tableId             4/4    100%
+ *   pullerId            2/2    100%
+ *
+ * Two findings worth stating plainly, because both contradict what was written down before:
+ *
+ *  1. **`taskId` is real, and is the most-used reference property in the corpus.** Story 3.7's AC
+ *     calls it "the ideation document's illustrative `taskId`, which does not exist" — that is
+ *     false. It appears 291 times in authored partials and resolves 651/651. The AC's underlying
+ *     instruction — key these to REAL property names — is right, and following it is what turned
+ *     up the error in its own example.
+ *  2. **`validationId`, `transformationId`, `pullerIds` and `pusherIds` were invented** from the
+ *     collection names and have zero authored occurrences. Removed. `pullerId` was on the same
+ *     guessed list but turned out to be real (2/2), so it is kept — on the measurement, not on
+ *     the fact that a `pullers` collection exists.
+ *
+ * The values are often COMPOSE-TIME TOKENS — `taskId: "**Sapo_Orders_Task_Id**"` — and they
+ * resolve because the graph keys components in token form (Story 3.1). Keying on substituted
+ * values would have made every one of these references dangle.
+ */
+/**
+ * CORRECTED 2026-08-02, and the correction is about METHOD, not about three names.
+ *
+ * The resolution rates in the table above were measured by asking *"is this value some
+ * component's id?"* — never *"does it point into the collection we claim?"*. Three consequences,
+ * each of which shipped:
+ *
+ *  1. **`connectionId` and `fromConnectionId` pointed at `connections`, a collection that does
+ *     not exist.** Corpus-wide: **0** authored files declare `connections:`, **281** declare
+ *     `connectors:`, and its ids are exactly the `**…ConnectionId**` tokens these properties
+ *     hold. `connectionId`, `fromConnectionId` and `connectorId` are three spellings of one
+ *     target: `connectors[*].id`. A method that only checked "is an id" scored the wrong
+ *     collection at 100%.
+ *  2. **`entityId` and `targetId` have no fixed collection — it comes from a SIBLING.** Measured
+ *     `entityType`: `SELF` 261 · `TASK` 118 · `PROFILE` 9. Measured `targetType`: `PULLER` 144 ·
+ *     `SCHEDULER` 105 · `REPORT` 44 · `SCHEMA` 43. `entityType: SELF` means "this task" and
+ *     carries no `entityId` at all. Absent, the type defaults to Task. A single `collection` field
+ *     cannot express this, which is why both were left collection-less — and a collection-less
+ *     entry matched a component in ANY collection and reported it resolved.
+ *  3. **They resolve only in `**Token**` form.** Authored value shapes: `entityId` 175 token /
+ *     1 raw UUID, `targetId` 151 / 0. The rule is not about volume — it is that the graph keys
+ *     components in TOKEN form (FR-45), so a raw UUID cannot match a component however it is
+ *     spelled. Reporting it as an unresolved reference would be noise; declining says the true
+ *     thing, and is a different answer from "a reference that does not resolve".
+ *
+ *     CORRECTED 2026-08-03. This first read "178 token-form vs 268 raw UUID … 437 legitimate
+ *     authored values" — measured over a population that included GENERATED `output.yaml`, where
+ *     compose has already substituted each token for the real id. The index never reads those
+ *     files, so those values were never at risk. The mistake is the same one this whole note is
+ *     about: a count that did not say precisely enough what it was counting.
+ *
+ * The lesson generalises: a reference is a property, a target collection AND a value shape. Any
+ * future re-derivation must assert all three, or it will score a wrong answer at 100% again.
+ */
+/**
+ * Values that are `**Token**` form — the only shape a conditional reference resolves in.
+ *
+ * TRIMMED, as of the Epic 2 review. It was not, while a second copy of this predicate 350 lines below was — so
+ * a quoted `" **Token** "` was a token to one and a literal to the other. One definition, one answer.
+ */
+const TOKEN_FORM = /^\*\*[^*]+\*\*$/;
+export const isTokenForm = (value) => TOKEN_FORM.test(value.trim());
+/** `entityType` → the collection an `entityId` beside it points into. */
+const ENTITY_TYPE_TARGETS = new Map([
+    ['TASK', 'objects'],
+    // "this task" — the entity IS the enclosing one, so there is no id to resolve.
+    ['SELF', undefined],
+    // A profile is not a template collection; the id is resolved outside the project.
+    ['PROFILE', undefined],
+]);
+/** `targetType` → the collection a `targetId` beside it points into. */
+const TARGET_TYPE_TARGETS = new Map([
+    ['PULLER', 'pullers'],
+    ['REPORT', 'reports'],
+    ['SCHEMA', 'schemas'],
+    ['SCHEDULER', 'startupTasks'],
+]);
+export const REFERENCE_PROPERTY_LIST = [
+    { property: 'taskId', collection: 'objects' },
+    { property: 'objectId', collection: 'objects' },
+    { property: 'object_id', collection: 'objects' },
+    { property: 'objectIds', collection: 'objects' },
+    { property: 'pusherId', collection: 'pushers' },
+    { property: 'pullerId', collection: 'pullers' },
+    { property: 'tableId', collection: 'tables' },
+    /**
+     * ADDED 2026-08-05, on measurement. A dependency names the Task it waits on with `dependedOn`.
+     *
+     * It was missing, and the omission was invisible because nothing asked for it: **910 authored
+     * occurrences across 665 files**, of which **271 of 272 (99.6%) resolve to a Task** when measured
+     * against composed graphs for all 33 buildable corpus projects. That is the same standard
+     * `NON_REFERENCE_ID_PROPERTIES` below applies in the other direction — a property measured at 0%
+     * resolution is not a reference, and one measured at 99.6% plainly is.
+     *
+     * The single miss is a REAL broken reference, in `001-projects/elly`: a `dependedOn` naming
+     * `**SapoProductPuller**`, a token that resolves to nothing and, by its name, aims at a puller
+     * where a Task belongs. Until now no validation, Find References or impact query could see it,
+     * because this row did not exist.
+     */
+    { property: 'dependedOn', collection: 'objects' },
+    // One target, three spellings. See the CORRECTED note above.
+    { property: 'connectionId', collection: 'connectors' },
+    { property: 'fromConnectionId', collection: 'connectors' },
+    // ...except on a `connectors[]` entry, where it is that connection's own platform identity rather
+    // than a reference to one. See `opaqueInCollections` on `ReferenceProperty`.
+    {
+        property: 'connectorId',
+        collection: 'connectors',
+        opaqueInCollections: ['connectors'],
+    },
+    {
+        property: 'entityId',
+        tokenFormOnly: true,
+        discriminator: {
+            siblings: ['entityType'],
+            byValue: ENTITY_TYPE_TARGETS,
+            fallback: 'objects',
+        },
+    },
+    {
+        property: 'targetId',
+        tokenFormOnly: true,
+        discriminator: {
+            // `targetType` decides; `entityType` is the fallback discriminator where the block carries
+            // one instead, and a Task is the default when neither is written.
+            siblings: ['targetType', 'entityType'],
+            byValue: new Map([...TARGET_TYPE_TARGETS, ...ENTITY_TYPE_TARGETS]),
+            fallback: 'objects',
+        },
+    },
+];
+/**
+ * Resolve what a reference property means beside its siblings.
+ *
+ * Returns `undefined` when this property/value/context is NOT a component reference — a raw UUID
+ * in `entityId`, or `entityType: SELF`. That is a distinct answer from "a reference that does not
+ * resolve", and collapsing the two is what puts diagnostics on correct files.
+ */
+export function resolveReferenceKind(property, value, siblings, 
+/**
+ * The collection whose entry this property sits inside — `connectors`, `pullers`, `objects`, … — as the
+ * walker already tracks it. Optional so existing callers keep compiling; supplying it is what lets a
+ * property mean one thing in a step argument and another on a component of its own collection (FR-47).
+ */
+enclosingCollection) {
+    const entry = BY_NAME.get(property);
+    if (!entry)
+        return undefined;
+    if (entry.tokenFormOnly && !isTokenForm(value))
+        return undefined;
+    // Checked BEFORE the discriminator: position decides whether there is a reference at all, and only then
+    // does anything ask what it points into.
+    if (enclosingCollection !== undefined &&
+        entry.opaqueInCollections?.includes(enclosingCollection)) {
+        return undefined;
+    }
+    if (!entry.discriminator) {
+        return {
+            property,
+            ...(entry.collection ? { collection: entry.collection } : {}),
+        };
+    }
+    const { siblings: names, byValue, fallback } = entry.discriminator;
+    for (const name of names) {
+        const raw = siblings?.[name];
+        if (raw === undefined || raw === null)
+            continue;
+        const key = String(raw);
+        // `has` rather than `get`, because a MAPPED `undefined` ("`SELF` references nothing") and an
+        // UNMAPPED value ("a type nobody has measured yet") are different answers that both come back
+        // as `undefined` from `get`. Claiming a collection for an unknown type is how this registry
+        // was wrong the first time.
+        if (!byValue.has(key))
+            return undefined;
+        const collection = byValue.get(key);
+        // Present, measured, and not a component reference — `entityType: SELF`, `PROFILE`.
+        if (collection === undefined)
+            return undefined;
+        return { property, collection };
+    }
+    return { property, ...(fallback ? { collection: fallback } : {}) };
+}
+/** Fast membership test for the walk in `queries.ts`. */
+export const REFERENCE_PROPERTIES = REFERENCE_PROPERTY_LIST.map((r) => r.property);
+const BY_NAME = new Map(REFERENCE_PROPERTY_LIST.map((r) => [r.property, r]));
+export const referencePropertyFor = (property) => BY_NAME.get(property);
+/**
+ * `*Id` properties MEASURED at 0% resolution — not references, recorded so their absence reads
+ * as a decision rather than an oversight.
+ *
+ * They hold runtime UUIDs, environment tokens or payload field names. Without this list the next
+ * reader sees `metricId` missing from the set above and adds it, and every metric configuration
+ * in the corpus grows a dangling-reference diagnostic.
+ *
+ * Every entry here has a row in the table above. `templateId` and `reportId` were previously
+ * listed and have been REMOVED: they never occurred in the sampled projects at all, so "resolved
+ * 0%" was never true of them — no-occurrences is not the same measurement as never-resolves, and
+ * a list whose stated basis is measurement must not carry entries that were only assumed. They
+ * do appear elsewhere in the corpus (`reportId` ~91 authored occurrences), so they are left
+ * deliberately unclassified until someone measures them.
+ */
+export const NON_REFERENCE_ID_PROPERTIES = [
+    'metricId',
+    'providerId',
+    'columnIds',
+    'systemId',
+    'integrationAppId',
+    'credentialId',
+    'profileId',
+    'itemIds',
+];
+/**
+ * Blocks whose `id` names a component — the corpus's DOMINANT reference form.
+ *
+ * `objectAssociations` wires a Task to its entities like this:
+ *
+ *     objectAssociations:
+ *       "**Orders_Task_Id**":
+ *         table:  { id: "**Orders_Table_Id**" }
+ *         puller: { id: "**Orders_Puller_Id**", resultKey: rows }
+ *
+ * Counted across the corpus's AUTHORED partials (`output.yaml` and `__configs` excluded):
+ *
+ *   nested `table:`  1,575      flat `tableId:`   308
+ *   nested `puller:` 1,695      flat `pullerId:`   38
+ *   nested `pusher:`   912      flat `pusherId:`   48
+ *                    -----                        ---
+ *                    4,182                        394
+ *
+ * The nested form outnumbers the flat one by roughly 10:1 — it is how the corpus wires a Task to
+ * its entities, and a registry built only on flat property names saw NONE of it. The flat form is
+ * a real minority, not noise, so both are supported.
+ *
+ * (An earlier draft of this comment said "4 / 2 / 5" and "three orders of magnitude". Those were
+ * the nine-project RESOLUTION sample from the table above, quoted under a corpus-wide heading —
+ * a different measurement of a different population. Corrected 2026-08-02.)
+ *
+ * The block carries more than the id (`resultKey`, for one), so the reference is the block's
+ * `id` specifically, reported as `table.id` rather than as `table`.
+ */
+export const NESTED_REFERENCE_BLOCKS = [
+    { property: 'table', collection: 'tables' },
+    { property: 'puller', collection: 'pullers' },
+    { property: 'pusher', collection: 'pushers' },
+];
+const NESTED_BY_NAME = new Map(NESTED_REFERENCE_BLOCKS.map((r) => [r.property, r]));
+export const nestedReferenceBlockFor = (property) => NESTED_BY_NAME.get(property);
+/**
+ * Collections whose component KEY is itself a reference into another collection.
+ *
+ * An `objectAssociations` entry is keyed BY the objectId it describes — that is what makes it
+ * that object's association rather than a component that merely shares its name. Modelling it
+ * matters twice: `getRelatedTask` can answer for an association, and renaming a Task has to
+ * carry the association key with it, which only shows up in a blast radius if the key is an edge.
+ */
+export const COLLECTIONS_KEYED_BY_REFERENCE = new Map([
+    ['objectAssociations', 'objects'],
+    /**
+     * ADDED 2026-08-06, on a reported bug: a Task's transformations and validations were invisible.
+     *
+     * Both are keyed by the Task they belong to, exactly as an association is — the key IS the objectId, and
+     * the value is that Task's list:
+     *
+     *     transformations:
+     *       "**MisaAmisSapoWeb__Inventories_Task_Id**":
+     *         - id: "**…_GetProductVariant_Transformation_Id**"
+     *           type: SQL
+     *
+     * Without the key modelled as a reference there is no edge between the two, so nothing could answer
+     * "which transformations does this Task have". Probed on `001-projects/catafa/sapo-misa`: the graph held
+     * 2 transformation and 5 validation components, and the Task's incoming relations were the association
+     * alone. The components were there; the edge was not.
+     *
+     * It matters twice, as the association's entry says: a query can answer for a Task, and renaming a Task
+     * carries its transformations and validations with it — which only shows up in a blast radius if the key
+     * is an edge.
+     */
+    ['transformations', 'objects'],
+    ['validations', 'objects'],
+]);
+/** The property name reported for a reference carried by a component's own key. */
+export const KEY_REFERENCE_PROPERTY = '(key)';
+/**
+ * The connector a connection names — `connectorId` first, `providerId` second (FR-1, AD-24).
+ *
+ * The read order exists in four places: `BaseStepExecutor` (untyped), `ConnectorDefinition.ResolvedConnectorId`
+ * (typed), `WebhookPartitioner` (via the accessor) and — found missing by the Epic 1 review — the CLI's task
+ * tooling. FR-1 says *every* runtime path, and the CLI reading only the legacy spelling meant a
+ * `connectorId`-only connection, exactly what FR-3's rename produces at scale, hard-stopped task generation
+ * with *"Connector undefined not found"*.
+ *
+ * Blank counts as absent, matching the untyped path: `Guid.Empty` has no equivalent here, but an empty string
+ * does, and a half-written `connectorId: ""` must not beat a real legacy value.
+ */
+export function resolvedConnectorIdOf(connection) {
+    const usable = (value) => {
+        const text = typeof value === 'string'
+            ? value
+            : typeof value === 'number'
+                ? String(value)
+                : undefined;
+        if (text === undefined || text.trim() === '')
+            return undefined;
+        // All-zeros counts as absent, matching `ConnectorIdentity.IsDeclared` in C#. The Epic 1 review found the
+        // two sides disagreeing about exactly this literal.
+        return text.trim() === '00000000-0000-0000-0000-000000000000'
+            ? undefined
+            : text;
+    };
+    return usable(connection?.connectorId) ?? usable(connection?.providerId);
+}
+/**
+ * A connector identity that is written but cannot be used (FR-9, Story 2.1).
+ *
+ * "Well formed" means a GUID. Not a name, not a slug, not a URL — the platform's connector registry is keyed by
+ * GUID, so anything else cannot resolve however plausible it looks.
+ *
+ * ⛔ ONE definition, deliberately. The same rule is expressed as a `pattern` in the shipped connection schema
+ * and as `ConnectorIdentity` in C#, and Epic 1's review found what happens when a rule this small gets written
+ * three times: the copies disagreed about an all-zeros GUID and nobody noticed, because the disagreeing input
+ * was the one case no suite covered. The schema, the rule and the runtime must answer the same question the
+ * same way.
+ *
+ * A compose-time TOKEN is not judged here. In composed output an unresolved `**Token**` means the VARIABLE
+ * failed to resolve, which `VAR-1` already reports — and two findings for one cause is how a Problems panel
+ * stops being read.
+ */
+const GUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+/**
+ * An identity that is STILL a token after composition — the variable failed, and `VAR-1` owns that.
+ *
+ * ⛔ A NAME for `isTokenForm`, not a second implementation. It shipped as a byte-identical copy of the regex
+ * 350 lines above its original, in the file whose own docstring says *"ONE definition, deliberately … Epic 1's
+ * review found what happens when a rule this small gets written three times."* Found by the Epic 2 review; kept
+ * as an alias rather than deleted because the two names say different things at their call sites — one asks
+ * "is this the shape a reference resolves in", the other "did substitution fail here".
+ */
+export const isUnresolvedToken = isTokenForm;
+export function isWellFormedConnectorIdentity(value) {
+    const trimmed = value.trim();
+    if (!GUID.test(trimmed))
+        return false;
+    // All-zeros is what an undeclared identity deserialises to on the typed side. It parses as a GUID and names
+    // no connector, so it is "absent" rather than "malformed" — `resolvedConnectorIdOf` already declines it.
+    return trimmed !== '00000000-0000-0000-0000-000000000000';
+}
+//# sourceMappingURL=references.js.map

package/dist/references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"references.js","sourceRoot":"","sources":["../src/references.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;GAKG;AACH,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAErC,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAW,EAAE,CACpD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;AAmDhC,yEAAyE;AACzE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAA6B;IAC9D,CAAC,MAAM,EAAE,SAAS,CAAC;IACnB,+EAA+E;IAC/E,CAAC,MAAM,EAAE,SAAS,CAAC;IACnB,kFAAkF;IAClF,CAAC,SAAS,EAAE,SAAS,CAAC;CACvB,CAAC,CAAC;AAEH,wEAAwE;AACxE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAA6B;IAC9D,CAAC,QAAQ,EAAE,SAAS,CAAC;IACrB,CAAC,QAAQ,EAAE,SAAS,CAAC;IACrB,CAAC,QAAQ,EAAE,SAAS,CAAC;IACrB,CAAC,WAAW,EAAE,cAAc,CAAC;CAC9B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAiC;IACnE,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE;IAC7C,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE;IAC/C,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;IAChD,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE;IAChD,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE;IAC/C,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE;IAC/C,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE;IAC7C;;;;;;;;;;;;;OAaG;IACH,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE;IACjD,6DAA6D;IAC7D,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE;IACtD,EAAE,QAAQ,EAAE,kBAAkB,EAAE,UAAU,EAAE,YAAY,EAAE;IAC1D,kGAAkG;IAClG,6EAA6E;IAC7E;QACE,QAAQ,EAAE,aAAa;QACvB,UAAU,EAAE,YAAY;QACxB,mBAAmB,EAAE,CAAC,YAAY,CAAC;KACpC;IACD;QACE,QAAQ,EAAE,UAAU;QACpB,aAAa,EAAE,IAAI;QACnB,aAAa,EAAE;YACb,QAAQ,EAAE,CAAC,YAAY,CAAC;YACxB,OAAO,EAAE,mBAAmB;YAC5B,QAAQ,EAAE,SAAS;SACpB;KACF;IACD;QACE,QAAQ,EAAE,UAAU;QACpB,aAAa,EAAE,IAAI;QACnB,aAAa,EAAE;YACb,2FAA2F;YAC3F,kEAAkE;YAClE,QAAQ,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC;YACtC,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,mBAAmB,EAAE,GAAG,mBAAmB,CAAC,CAAC;YAClE,QAAQ,EAAE,SAAS;SACpB;KACF;CACF,CAAC;AAUF;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAAgB,EAChB,KAAa,EACb,QAAkC;AAClC;;;;GAIG;AACH,mBAA4B;IAE5B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACpC,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,IAAI,KAAK,CAAC,aAAa,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACjE,wGAAwG;IACxG,yCAAyC;IACzC,IACE,mBAAmB,KAAK,SAAS;QACjC,KAAK,CAAC,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB,CAAC,EACxD,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QACzB,OAAO;YACL,QAAQ;YACR,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC9D,CAAC;IACJ,CAAC;IAED,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,aAAa,CAAC;IACnE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI;YAAE,SAAS;QAChD,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QACxB,6FAA6F;QAC7F,8FAA8F;QAC9F,4FAA4F;QAC5F,4BAA4B;QAC5B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QACxC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,oFAAoF;QACpF,IAAI,UAAU,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC/C,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;IAClC,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AACrE,CAAC;AAED,yDAAyD;AACzD,MAAM,CAAC,MAAM,oBAAoB,GAC/B,uBAAuB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AAEjD,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,QAAgB,EACe,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAsB;IAC5D,UAAU;IACV,YAAY;IACZ,WAAW;IACX,UAAU;IACV,kBAAkB;IAClB,cAAc;IACd,WAAW;IACX,SAAS;CACV,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAiC;IACnE,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE;IAC3C,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE;IAC7C,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE;CAC9C,CAAC;AAEF,MAAM,cAAc,GAAG,IAAI,GAAG,CAC5B,uBAAuB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CACpD,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,QAAgB,EACe,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,8BAA8B,GACzC,IAAI,GAAG,CAAC;IACN,CAAC,oBAAoB,EAAE,SAAS,CAAC;IACjC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,iBAAiB,EAAE,SAAS,CAAC;IAC9B,CAAC,aAAa,EAAE,SAAS,CAAC;CAC3B,CAAC,CAAC;AAEL,mFAAmF;AACnF,MAAM,CAAC,MAAM,sBAAsB,GAAG,OAAO,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACnC,UACoE;IAEpE,MAAM,MAAM,GAAG,CAAC,KAAc,EAAE,EAAE;QAChC,MAAM,IAAI,GACR,OAAO,KAAK,KAAK,QAAQ;YACvB,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ;gBACzB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBACf,CAAC,CAAC,SAAS,CAAC;QAClB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,OAAO,SAAS,CAAC;QAC/D,yGAAyG;QACzG,oDAAoD;QACpD,OAAO,IAAI,CAAC,IAAI,EAAE,KAAK,sCAAsC;YAC3D,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,IAAI,CAAC;IACX,CAAC,CAAC;IACF,OAAO,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,IAAI,GACR,+EAA+E,CAAC;AAElF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;AAE7C,MAAM,UAAU,6BAA6B,CAAC,KAAa;IACzD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IACtC,4GAA4G;IAC5G,yGAAyG;IACzG,OAAO,OAAO,KAAK,sCAAsC,CAAC;AAC5D,CAAC"}

package/dist/stepGlyph.d.ts

@@ -0,0 +1,67 @@
+/**
+ * A node's label: name, then key, then the step type — with a glyph standing in for an icon.
+ *
+ * ### What was wrong, and it was one line in each renderer
+ *
+ * Both `render.ts` files built a label as `node.label ?? node.name ?? node.stepKey ?? node.address` — a
+ * FALLBACK chain, so a step with a name showed its name and nothing else. The key and the type were computed,
+ * carried on every node, and then dropped at the last step before drawing. A reader looking at a diagram
+ * beside the YAML could not tell which `key:` a box was, which is the one thing they need in order to jump to
+ * it, and `next:`/`outputs:` reference steps BY KEY.
+ *
+ * The brainstorm that started this feature asked for exactly this: *"each node is missing its `key` and
+ * `type/displayType` … The key must be after the node's `name`, and the `type/displayType` must be shown as an
+ * icon in the node"*.
+ *
+ * ### Why a glyph and not the SVG set
+ *
+ * ⚠️ Stated rather than quietly downgraded. `ux/step-icons/` holds 12 authored SVGs, and they cannot go inside
+ * a mermaid node here: the webview renders with `securityLevel: 'strict'`, which sanitises label HTML through
+ * DOMPurify (`renderHtml.ts:493` records the same constraint for the report), and an inline `<svg>` does not
+ * survive that. Raising it to `'loose'` to admit one would also admit mermaid's `click … call fn()` — which is
+ * precisely why `flowDiagram.ts` chose strict.
+ *
+ * So the icon slot is filled by a per-FAMILY unicode glyph, which survives sanitising, needs no asset
+ * pipeline, and renders identically in the editor, the report and the browser host. The type name is drawn
+ * beside it, so the glyph is a hint and never the only signal — that is the "fallback to text", present
+ * always rather than only when something fails.
+ *
+ * Wiring the real SVG set belongs with the shared step-icon package the toolchain PRD lists under
+ * *"Unblocks"*, where a `<span class="step-icon step-icon--api">` and CSS can do it without loosening mermaid.
+ */
+/**
+ * Which family a step type belongs to.
+ *
+ * Matched on the type name because that is what both runtimes carry — a worker step's `displayType` and a
+ * frontend step's `type` are the same idea spelled twice (AD-21 keeps the vocabularies apart, not the
+ * concept). Unknown types get the neutral glyph rather than no glyph, so a box never loses its icon slot and
+ * start shifting the text alignment of its neighbours.
+ */
+export declare function familyOfStepType(type: string): string;
+/**
+ * The glyph for a step type.
+ *
+ * Empty for a step with NO type — there is no icon to stand in for, and a placeholder would render as a
+ * second separator (`name · · KEY`), which is how this was caught.
+ */
+export declare function glyphOfStepType(type: string | undefined): string;
+/**
+ * The three lines a reader needs, in the order the brainstorm asked for: name, then key, then type.
+ *
+ * ⚠️ ONE LINE, not `<br/>`, and that was measured rather than assumed. The first version used `<br/>`; the
+ * shared renderer's `escapeLabel` turns `<` into `&lt;` — correctly, it is what stops an authored step name
+ * injecting markup — so mermaid received `&lt;br/&gt;` and would have drawn it as visible text in every box.
+ * Weakening `escapeLabel` to admit one tag would trade a real safety property for a cosmetic one.
+ *
+ * A junction (START/END) has its own label and no key or type — it returns unchanged, because decorating a
+ * terminal with an empty key line would put a blank row in every diagram.
+ */
+export declare function composeNodeLabel(node: {
+    readonly label?: string;
+    readonly name?: string;
+    readonly stepKey?: string;
+    readonly address: string;
+    readonly type?: string;
+    readonly displayType?: string;
+}): string;
+//# sourceMappingURL=stepGlyph.d.ts.map

package/dist/stepGlyph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepGlyph.d.ts","sourceRoot":"","sources":["../src/stepGlyph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA4CH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BrD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,MAAM,CAYT"}

package/dist/stepGlyph.js

@@ -0,0 +1,155 @@
+/**
+ * A node's label: name, then key, then the step type — with a glyph standing in for an icon.
+ *
+ * ### What was wrong, and it was one line in each renderer
+ *
+ * Both `render.ts` files built a label as `node.label ?? node.name ?? node.stepKey ?? node.address` — a
+ * FALLBACK chain, so a step with a name showed its name and nothing else. The key and the type were computed,
+ * carried on every node, and then dropped at the last step before drawing. A reader looking at a diagram
+ * beside the YAML could not tell which `key:` a box was, which is the one thing they need in order to jump to
+ * it, and `next:`/`outputs:` reference steps BY KEY.
+ *
+ * The brainstorm that started this feature asked for exactly this: *"each node is missing its `key` and
+ * `type/displayType` … The key must be after the node's `name`, and the `type/displayType` must be shown as an
+ * icon in the node"*.
+ *
+ * ### Why a glyph and not the SVG set
+ *
+ * ⚠️ Stated rather than quietly downgraded. `ux/step-icons/` holds 12 authored SVGs, and they cannot go inside
+ * a mermaid node here: the webview renders with `securityLevel: 'strict'`, which sanitises label HTML through
+ * DOMPurify (`renderHtml.ts:493` records the same constraint for the report), and an inline `<svg>` does not
+ * survive that. Raising it to `'loose'` to admit one would also admit mermaid's `click … call fn()` — which is
+ * precisely why `flowDiagram.ts` chose strict.
+ *
+ * So the icon slot is filled by a per-FAMILY unicode glyph, which survives sanitising, needs no asset
+ * pipeline, and renders identically in the editor, the report and the browser host. The type name is drawn
+ * beside it, so the glyph is a hint and never the only signal — that is the "fallback to text", present
+ * always rather than only when something fails.
+ *
+ * Wiring the real SVG set belongs with the shared step-icon package the toolchain PRD lists under
+ * *"Unblocks"*, where a `<span class="step-icon step-icon--api">` and CSS can do it without loosening mermaid.
+ */
+/**
+ * Families, taken from the authored icon set (`ux/step-icons/_family-*.svg`) so the two cannot diverge.
+ *
+ * ⚠️ EVERY glyph must come from Arrows (U+2190–U+21FF), Geometric Shapes (U+25A0–U+25FF) or Mathematical
+ * Operators (U+2200–U+22FF), and `stepGlyph.spec.ts` enforces it. Those three blocks have near-universal
+ * coverage in the fonts a webview actually gets; anything outside them draws as a tofu box on some machine,
+ * and a box is indistinguishable from "this node has no icon".
+ *
+ * Two of the first ten broke that rule and a reader saw both: *"why are some nodes have icons, but some are
+ * not?"*
+ *
+ *  * `query` was `?` — a plain ASCII question mark. It has perfect coverage and reads as a MISSING
+ *    CHARACTER, which is worse: the glyph rendered exactly as intended and still looked like a failure.
+ *  * `control` was `⑂` (U+2442), in the Optical Character Recognition block. Rare enough that common fonts
+ *    omit it, so it drew as a box.
+ *
+ * The lesson is that "does this codepoint exist" is the wrong question. The right one is "does it read as an
+ * icon on a machine I have never seen", and the answer is only reliable inside those three blocks.
+ */
+const GLYPHS = {
+    /** An outbound request. */
+    call: '↗',
+    /** A branch. The diamond shape the flow already draws for a decision, in the label. */
+    control: '◆',
+    /** Fan-out — dispatch, loop, batch. */
+    orchestrate: '↻',
+    /** Rows read back. Was `?`, which read as a missing character. */
+    query: '≡',
+    /** Something remembered for the rest of the run. */
+    state: '▣',
+    /** A start or an end. */
+    terminal: '◉',
+    /** Shape in, different shape out. */
+    transform: '⇄',
+    /** A screen the operator sees. */
+    ui: '▤',
+    /** Time passing. */
+    wait: '◔',
+    /** Data pushed somewhere. */
+    write: '⇩',
+};
+/**
+ * Which family a step type belongs to.
+ *
+ * Matched on the type name because that is what both runtimes carry — a worker step's `displayType` and a
+ * frontend step's `type` are the same idea spelled twice (AD-21 keeps the vocabularies apart, not the
+ * concept). Unknown types get the neutral glyph rather than no glyph, so a box never loses its icon slot and
+ * start shifting the text alignment of its neighbours.
+ */
+export function familyOfStepType(type) {
+    const t = type.toUpperCase();
+    if (/FORM|SHOW|SELECT|REDIRECT|BROWSER|MESSAGE|INFO/.test(t))
+        return 'ui';
+    if (/^API$|HTTP|REQUEST|WEBHOOK|CALL/.test(t))
+        return 'call';
+    /**
+     * WAIT before everything else that could claim it.
+     *
+     * `SLEEP` is a real corpus type (`MisaAmisCustomerCallbackMessagePusher.yaml` carries one) and the authored
+     * set drew it its own clock. Ahead of `query` because `POLL` contains no query word but reads as one, and
+     * ahead of `state` because `WAIT_FOR_RECENT_USER_CREATED` — an authored KEY, not a type — must not be
+     * classified by a substring of its name if it ever reaches here as one.
+     */
+    if (/SLEEP|WAIT|DELAY|POLL|RETRY|SCHEDULE/.test(t))
+        return 'wait';
+    if (/SQL|QUERY|FIND|GET|READ|FETCH/.test(t))
+        return 'query';
+    /**
+     * WRITE before STATE, because the authored set separates them and the words overlap.
+     *
+     * `write` is a step that PUSHES data somewhere — insert, upsert, seed, push. `state` is a step that
+     * remembers something for the rest of the run — `SET_STORAGE`, `REGISTER_*`. `SAVE` and `WRITE` were in
+     * the state bucket and belong here; `SET_` and `STORAGE` stay there.
+     */
+    if (/WRITE|INSERT|UPSERT|SEED|PUSH|CREATE|DELETE/.test(t))
+        return 'write';
+    if (/SET_|STORAGE|SAVE|UPDATE|REGISTER/.test(t))
+        return 'state';
+    if (/MAP|TRANSFORM|CONVERT|FORMAT/.test(t))
+        return 'transform';
+    if (/FORWARD|DISPATCH|LOOP|EACH|BATCH/.test(t))
+        return 'orchestrate';
+    if (/IF|SWITCH|CONDITION|BRANCH/.test(t))
+        return 'control';
+    if (/END|STOP|FAIL|COMPLETE|START/.test(t))
+        return 'terminal';
+    return 'orchestrate';
+}
+/**
+ * The glyph for a step type.
+ *
+ * Empty for a step with NO type — there is no icon to stand in for, and a placeholder would render as a
+ * second separator (`name · · KEY`), which is how this was caught.
+ */
+export function glyphOfStepType(type) {
+    if (!type)
+        return '';
+    return GLYPHS[familyOfStepType(type)] ?? '·';
+}
+/**
+ * The three lines a reader needs, in the order the brainstorm asked for: name, then key, then type.
+ *
+ * ⚠️ ONE LINE, not `<br/>`, and that was measured rather than assumed. The first version used `<br/>`; the
+ * shared renderer's `escapeLabel` turns `<` into `&lt;` — correctly, it is what stops an authored step name
+ * injecting markup — so mermaid received `&lt;br/&gt;` and would have drawn it as visible text in every box.
+ * Weakening `escapeLabel` to admit one tag would trade a real safety property for a cosmetic one.
+ *
+ * A junction (START/END) has its own label and no key or type — it returns unchanged, because decorating a
+ * terminal with an empty key line would put a blank row in every diagram.
+ */
+export function composeNodeLabel(node) {
+    const type = node.type ?? node.displayType;
+    const heading = node.label ?? node.name ?? node.stepKey ?? node.address;
+    // A junction, or a node carrying neither of the two facts this function exists to add.
+    if (!node.stepKey && !type)
+        return heading;
+    // The glyph leads the added half rather than the whole label, so the NAME stays what the eye lands on.
+    // Every part is filtered, so a key with no type (or the reverse) yields ONE separator, not an empty slot.
+    const second = [glyphOfStepType(type), [node.stepKey, type].filter(Boolean).join(' · ')]
+        .filter(Boolean)
+        .join(' ');
+    return second ? `${heading} · ${second}` : heading;
+}
+//# sourceMappingURL=stepGlyph.js.map

package/dist/stepGlyph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepGlyph.js","sourceRoot":"","sources":["../src/stepGlyph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,GAAqC;IAC/C,2BAA2B;IAC3B,IAAI,EAAE,GAAG;IACT,uFAAuF;IACvF,OAAO,EAAE,GAAG;IACZ,uCAAuC;IACvC,WAAW,EAAE,GAAG;IAChB,kEAAkE;IAClE,KAAK,EAAE,GAAG;IACV,oDAAoD;IACpD,KAAK,EAAE,GAAG;IACV,yBAAyB;IACzB,QAAQ,EAAE,GAAG;IACb,qCAAqC;IACrC,SAAS,EAAE,GAAG;IACd,kCAAkC;IAClC,EAAE,EAAE,GAAG;IACP,oBAAoB;IACpB,IAAI,EAAE,GAAG;IACT,6BAA6B;IAC7B,KAAK,EAAE,GAAG;CACX,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC7B,IAAI,gDAAgD,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1E,IAAI,iCAAiC,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,MAAM,CAAC;IAC7D;;;;;;;OAOG;IACH,IAAI,sCAAsC,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,MAAM,CAAC;IAClE,IAAI,+BAA+B,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IAC5D;;;;;;OAMG;IACH,IAAI,6CAA6C,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IAC1E,IAAI,mCAAmC,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IAChE,IAAI,8BAA8B,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,WAAW,CAAC;IAC/D,IAAI,kCAAkC,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,aAAa,CAAC;IACrE,IAAI,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IAC3D,IAAI,8BAA8B,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,UAAU,CAAC;IAC9D,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,IAAwB;IACtD,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,OAAO,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAOhC;IACC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC;IAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;IACxE,uFAAuF;IACvF,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI;QAAE,OAAO,OAAO,CAAC;IAE3C,uGAAuG;IACvG,0GAA0G;IAC1G,MAAM,MAAM,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACrF,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,MAAM,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;AACrD,CAAC"}