canicode 0.10.2 → 0.10.3

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "canicode",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "mcpName": "io.github.let-sunny/canicode",
-  "description": "Score your Figma designs with AI-calibrated rules. CLI + MCP server.",
+  "description": "Lint Figma designs for AI code-gen and roundtrip the answers back into the file. CLI + MCP server.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/skills/canicode-roundtrip/SKILL.md

@@ -90,6 +90,12 @@ Build the message from the question fields. **If `question.instanceContext` is p
 _Instance note: This layer is inside an instance. Layout and size fixes may need to be applied on source component **{sourceComponentName or sourceComponentId or "unknown"}** (definition node `sourceNodeId`) and propagate to all instances — you will be asked to confirm before any definition-level write._
 ```
 
+**If `question.replicas` is present (#356 dedup)**, prepend a second line noting the answer applies to N instances:
+
+```
+_Replicas: This question represents **{replicas} instances** of the same source-component child sharing the same rule. Your single answer will be applied to all of them in Step 4 (one annotation/write per instance scene)._
+```
+
 Then the standard block:
 
 ```
@@ -131,6 +137,8 @@ Every gotcha-survey question (and every entry in `analyzeResult.issues[]`) carri
 | `isInstanceChild` | `boolean` | Whether the `nodeId` targets a node inside an INSTANCE subtree. |
 | `sourceChildId` | `string` \| (absent) | Definition node id inside the source component. Use directly with `figma.getNodeByIdAsync`. |
 | `instanceContext` | object \| (absent) | Survey questions only. `{ parentInstanceNodeId, sourceNodeId, sourceComponentId?, sourceComponentName? }` for the Step 3 user-facing note. |
+| `replicas` | `number` \| (absent) | Survey questions only (#356). Total instance count when this one question represents N instance-child issues sharing the same `(sourceComponentId, sourceNodeId, ruleId)` tuple. Absent for single-instance questions. |
+| `replicaNodeIds` | `string[]` \| (absent) | Survey questions only (#356). All OTHER instance scene node ids the answer should land on. The apply step iterates `[nodeId, ...replicaNodeIds]`. Absent when `replicas` is absent. |
 
 #### Instance-child property overridability (Plugin API)
 
@@ -177,6 +185,51 @@ The helper walks the tiers in order; variable binding is an alternative writeFn
 
 **Confirmation is a batch-level concern — and only needed when opting in.** A `use_figma` call runs one JavaScript batch and cannot pause mid-batch for user input. Under the ADR-012 default (`allowDefinitionWrite: false`), no propagation happens, so no confirmation is required — override-errors annotate and move on. The orchestrator sets `allowDefinitionWrite: true` only after enumerating the likely propagation set to the user up-front and collecting **one confirmation for the whole batch** that names the source component(s) and the affected instance set. When describing impact, note that the write reaches every **non-overridden** instance — any instance with a local override for the same property keeps its override. The helper below never prompts — it assumes that if the flag is on, confirmation already happened.
 
+**Pre-flight writability probe (#357).** Before showing the user the Definition write picker, call `CanICodeRoundtrip.probeDefinitionWritability(questions)` inside a small `use_figma` batch. The probe loads every distinct `sourceChildId` once and classifies it as writable or unwritable using the same detection as the runtime fallback (Experiment 10 `remote === true` and Experiment 11 unresolved-`null`). The result decides which version of the picker to show:
+
+```javascript
+// Inside a use_figma batch:
+const probe = await CanICodeRoundtrip.probeDefinitionWritability(questions);
+return { events: [], probe };
+```
+
+Branches on `probe`:
+
+- **`allUnwritable === true`** — every candidate source is in an external library (or unresolved). Opting in is structurally a no-op; every write would throw "Cannot write to internal and read-only node" and fall through to scene annotation anyway. Show the user a single-option picker:
+
+  ```
+  Definition write policy
+
+  This file's source components live in an external library and are
+  read-only from here ({unwritableSourceNames.join(", ")}). Tier 2
+  propagation cannot fire — every "opt-in" write would fall through
+  to a scene annotation regardless.
+
+  ❯ 1. Annotate only (only viable option for this file)
+    2. Cancel — duplicate the library locally first to enable propagation
+  ```
+
+  Skip the opt-in branch entirely and call the helpers with the default `allowDefinitionWrite: false`.
+
+- **`partiallyUnwritable === true`** — some sources are local, some remote. Surface the split:
+
+  ```
+  Definition write policy
+
+  {unwritableCount} of {totalCount} source components are remote
+  (read-only) and will fall through to annotation; the remaining
+  {totalCount - unwritableCount} are local and will propagate.
+  Remote sources: {unwritableSourceNames.join(", ")}.
+
+  Continue with allowDefinitionWrite: true?
+  ```
+
+  When confirmed, propagate to the local sources and let the helper's runtime fallback annotate the remote ones — the existing Experiment-10 retry path absorbs them without aborting the batch.
+
+- **`allUnwritable === false && partiallyUnwritable === false`** (the all-local / no-candidates case) — show the existing batch-level picker prose. No probe-driven adjustment needed.
+
+The probe is read-only and idempotent; running it before the picker adds one round-trip but saves the user a confusing "I opted in, why did I get annotations?" moment that #342 surfaced live on Simple Design System (Community).
+
 **Shared helpers (bundled)** — the deterministic helpers live in TypeScript at `src/core/roundtrip/*.ts` and are bundled to a single IIFE at `.claude/skills/canicode-roundtrip/helpers.js`. `use_figma` only accepts a self-contained JS string, so the source of truth is TypeScript (with vitest coverage) and the bundle is the delivery artifact.
 
 **Usage in a roundtrip session:**
@@ -185,11 +238,12 @@ The helper walks the tiers in order; variable binding is an alternative writeFn
 2. Prepend its contents verbatim at the top of every `use_figma` batch body — it registers a single global `CanICodeRoundtrip`.
 3. Reference exposed globals as `CanICodeRoundtrip.*`:
    - `stripAnnotations(annotations)` — normalizes the D1 label/labelMarkdown mutex on readback.
-   - `ensureCanicodeCategories()` — returns `{ gotcha, autoFix, fallback }` category id map (D4); idempotent, safe to call at the top of every batch.
+   - `ensureCanicodeCategories()` — returns `{ gotcha, flag, fallback }` category id map (D4); idempotent, safe to call at the top of every batch. May also include `legacyAutoFix` when the file already carries the pre-#355 `canicode:auto-fix` category from earlier roundtrips — read-only on the canicode side, used only by Step 5 cleanup to sweep old annotations.
    - `upsertCanicodeAnnotation(node, { ruleId, markdown, categoryId, properties })` — idempotent annotation upsert. Handles D1 mutex, D2 in-place replace by ruleId prefix, and the D3 `properties` node-type retry.
    - `applyWithInstanceFallback(question, writeFn, { categories, allowDefinitionWrite, telemetry })` — three-tier write policy with silent-ignore detection. `allowDefinitionWrite` defaults to `false` per ADR-012 — override-errors and silent-ignores annotate the scene naming the source component instead of writing the definition. Set `true` only after a batch-level confirmation. `telemetry` is an optional `(event, props) => void` callback fired when a definition write is skipped (wiring point for future Node-side opt-in usage data). The `writeFn` may return `false` to signal "write accepted but value unchanged" so the helper can route to the next tier.
    - `applyPropertyMod(question, answerValue, { categories, allowDefinitionWrite, telemetry })` — Strategy A entry point. Branches on `targetProperty` (single vs array) and answer shape (scalar, per-property object, `{ variable: "name" }` binding). Uses `setBoundVariableForPaint` for `fills` / `strokes` and `setBoundVariable` for scalar fields. Passes the full context through to `applyWithInstanceFallback`.
    - `resolveVariableByName(name)` — local-variable exact-name lookup; returns `null` for remote library variables not imported into this file.
+   - `probeDefinitionWritability(questions)` — async pre-flight (#357). Returns `{ totalCount, unwritableCount, unwritableSourceNames, allUnwritable, partiallyUnwritable }`. Use BEFORE the Definition write picker so the picker can drop the opt-in branch when every candidate is in an external library / unresolved (saves the user a wasted "I opted in, why did I get annotations?" decision). Read-only probe, dedupes by `sourceChildId`.
 
 Keep each `writeFn` small so a throw does not abort unrelated writes. Experiment 08 findings informed every branch in the bundled helpers, and the batch-level confirmation contract still applies *when opting in*: if the orchestrator passes `allowDefinitionWrite: true`, it must have already collected one confirmation covering every potential definition write in the batch. Under the default, no confirmation is needed — the helper annotates the scene instead of propagating.
 
@@ -203,6 +257,15 @@ Rules with `applyStrategy === "property-mod"`. Call the bundled helper — it br
 await CanICodeRoundtrip.applyPropertyMod(question, answerValue, { categories });
 ```
 
+**Replicas (#356)** — when `question.replicaNodeIds` is present, the same answer must land on every replica instance. Iterate the merged set so each scene gets its own per-node failure routing (under the ADR-012 default each replica annotates independently; with `allowDefinitionWrite: true` they share the one definition write because they share the source):
+
+```javascript
+const targets = [question.nodeId, ...(question.replicaNodeIds ?? [])];
+for (const nodeId of targets) {
+  await CanICodeRoundtrip.applyPropertyMod({ ...question, nodeId }, answerValue, { categories });
+}
+```
+
 Answer shape guide (LLM judgment — the user's answer is prose; parse accordingly):
 - **`non-semantic-name`**: string — the new node name.
 - **`irregular-spacing`**: number for gap (subType `gap`), or `{ paddingTop, paddingRight, paddingBottom, paddingLeft }` for padding.
@@ -244,22 +307,25 @@ If the user **declines** any structural modification, add an annotation instead
 
 #### Strategy C: Annotation — record on the design for designer reference
 
-Rules with `applyStrategy === "annotation"` cannot be auto-fixed via Plugin API. Add the gotcha answer as a Figma annotation so designers see it in Dev Mode. Use the helper — it handles the D1 mutex, D2 in-place upsert, and D4 category assignment.
+Rules with `applyStrategy === "annotation"` cannot be auto-fixed via Plugin API. Add the gotcha answer as a Figma annotation so designers see it in Dev Mode. Use the helper — it handles the D1 mutex, D2 in-place upsert, and D4 category assignment. When `question.replicaNodeIds` is present (#356), iterate the merged set so every replica instance gets the annotation:
 
 ```javascript
-const scene = await figma.getNodeByIdAsync(question.nodeId);
-CanICodeRoundtrip.upsertCanicodeAnnotation(scene, {
-  ruleId: question.ruleId,
-  markdown: `**Q:** ${question.question}\n**A:** ${answer}`,
-  categoryId: categories.gotcha,
-  // Optional: surface live property values in Dev Mode alongside the note.
-  // Only include types the node supports (FRAME vs TEXT — see matrix above).
-  properties: question.annotationProperties,
-});
+const targets = [question.nodeId, ...(question.replicaNodeIds ?? [])];
+for (const nodeId of targets) {
+  const scene = await figma.getNodeByIdAsync(nodeId);
+  CanICodeRoundtrip.upsertCanicodeAnnotation(scene, {
+    ruleId: question.ruleId,
+    markdown: `**Q:** ${question.question}\n**A:** ${answer}`,
+    categoryId: categories.gotcha,
+    // Optional: surface live property values in Dev Mode alongside the note.
+    // Only include types the node supports (FRAME vs TEXT — see matrix above).
+    properties: question.annotationProperties,
+  });
+}
 ```
 
 Notes:
-- `upsertCanicodeAnnotation` replaces an existing `**[canicode] <ruleId>**` entry on the same node instead of appending — reruns don't accumulate duplicates.
+- `upsertCanicodeAnnotation` writes the recommendation directly as the body and appends an italic `— *<ruleId>*` footer. The footer is the dedup marker — reruns replace the existing entry in place. The category badge (`canicode:gotcha` / `canicode:flag` / `canicode:fallback`) above the body already brands the annotation, so the body no longer leads with `**[canicode] <ruleId>**` (#353). Pre-#353 entries are still recognised on rerun and replaced with the new format.
 - `label` and `labelMarkdown` are mutually exclusive on write, but Figma returns both on readback. Never spread `scene.annotations` directly; always call `CanICodeRoundtrip.upsertCanicodeAnnotation` (or `CanICodeRoundtrip.stripAnnotations` if you truly need the normalized array).
 - Prefer annotating the **scene** instance child so designers see the note where they work; mention in the markdown if the fix belongs on the source component but could not be applied (library/external).
 
@@ -289,7 +355,7 @@ for (const issue of analyzeResult.issues) {
     CanICodeRoundtrip.upsertCanicodeAnnotation(scene, {
       ruleId: issue.ruleId,
       markdown: issue.message,
-      categoryId: categories.autoFix,
+      categoryId: categories.flag,
       // Optional: surface the live value for the affected property in Dev Mode.
       properties: issue.annotationProperties,
     });
@@ -305,7 +371,7 @@ for (const issue of analyzeResult.issues) {
 1. **Batch all property modifications** (Strategy A) into a single `use_figma` call for efficiency. Pass `{ categories }` to `applyWithInstanceFallback` so fallbacks land in the correct category.
 2. **Present structural modifications** (Strategy B) one by one, apply confirmed ones.
 3. **Batch all annotations** (Strategy C + declined structural mods) into a single `use_figma` call — use `categories.gotcha` for the category id.
-4. **Batch all auto-fixes and annotations for lower-severity issues** (Strategy D) — use `categories.autoFix` for annotated ones, `categories.fallback` is reserved for errors surfaced by `applyWithInstanceFallback` itself.
+4. **Batch all auto-fixes and annotations for lower-severity issues** (Strategy D) — use `categories.flag` for annotated ones (renamed from `autoFix` per #355 — the category means "flagged for designer attention", not "fixed"), `categories.fallback` is reserved for errors surfaced by `applyWithInstanceFallback` itself.
 
 After applying, report what was done:
 
@@ -318,7 +384,7 @@ Applied {N} changes to the Figma design:
 - ⏭️ {nodeName}: declined by user, added annotation (deep-nesting)
 - 📝 {nodeName}: annotation added to canicode:gotcha (absolute-position-in-auto-layout)
 - 🔧 {nodeName}: auto-fixed to "Hover" (non-standard-naming)
-- 📝 {nodeName}: annotation added to canicode:auto-fix — raw color needs token binding (raw-value)
+- 📝 {nodeName}: annotation added to canicode:flag — raw color needs token binding (raw-value)
 ```
 
 ### Step 5: Re-analyze and report what the roundtrip addressed
@@ -355,14 +421,18 @@ If Step 4 produced no report block (e.g. user skipped every question, or no gotc
 
   Grade: {oldGrade} → {newGrade}. Ready for code generation.
   ```
-- Clean up canicode annotations: remove annotations with `[canicode]` prefix from fixed nodes via `use_figma`. Apply `stripAnnotations` to avoid the D1 mutex:
+- Clean up canicode annotations on fixed nodes via `use_figma`. Filter by **categoryId** (the durable canicode-side identifier — the body no longer carries a `[canicode]` prefix per #353). Include `legacyAutoFix` if `ensureCanicodeCategories` returned it, so pre-#355 `canicode:auto-fix` entries get swept too. The trailing `— *<ruleId>*` footer is kept as a secondary marker for legacy `[canicode]`-prefix entries that may exist on files that have not been re-roundtripped yet:
 ```javascript
+const canicodeIds = new Set(
+  [categories.gotcha, categories.flag, categories.fallback, categories.legacyAutoFix].filter(Boolean)
+);
 const nodeIds = ["id1", "id2"]; // nodes that now pass
 for (const id of nodeIds) {
   const node = await figma.getNodeByIdAsync(id);
   if (node && "annotations" in node) {
     node.annotations = CanICodeRoundtrip.stripAnnotations(node.annotations).filter(
-      a => !a.labelMarkdown?.startsWith("**[canicode]")
+      a => !(a.categoryId && canicodeIds.has(a.categoryId)) &&
+           !a.labelMarkdown?.startsWith("**[canicode]")
     );
   }
 }
@@ -384,7 +454,23 @@ for (const id of nodeIds) {
   Grade: {oldGrade} → {newGrade}. Proceed to code generation with remaining context?
   ```
 - If yes → proceed to **Step 6** with remaining gotcha context.
-- If no → stop and let the user address remaining issues manually.
+- If no → stop and emit the **Stop wrap-up** below; do **not** restate the grade as the lead.
+
+#### Wrap-up message rubric (Stop branch)
+
+When the user picks **Stop** here, the closing message is the *last thing the user sees of canicode* in this session. Keep the issues-delta as the headline (`✅ X / 📝 Y / 🌐 Z / ⏭️ W / V remaining`) — grade movement, if any, belongs as a footnote line **after** the delta, not as the lead bullet. Reason: the value canicode delivers under the ADR-012 default is the annotation count carried into code-gen, not score movement (per [#341](https://github.com/let-sunny/canicode/issues/341), [#352](https://github.com/let-sunny/canicode/issues/352)).
+
+```
+Stopped — N issues addressed, V remaining for manual follow-up:
+  ✅  X resolved
+  📝  Y annotated on Figma (carried into code-gen via canicode-gotchas)
+  🌐  Z definition writes propagated
+  ⏭️  W skipped
+
+Grade: {oldGrade} → {newGrade}.
+```
+
+Anti-pattern (do **not** lead with a grade-only sentence like "Grade: C → C+. Most size-constraint gotchas are now annotations…"). Lead with the delta block; mention grade once, on its own footnote line, plain prose only.
 
 ### Step 6: Implement with Figma MCP
 
@@ -399,6 +485,23 @@ Follow the **figma-implement-design** skill workflow to generate code from the F
 
 **If all issues were resolved in Steps 4-5**, no additional gotcha context is needed — the design speaks for itself.
 
+#### Wrap-up message rubric (post-handoff)
+
+After `figma-implement-design` returns, summarise the roundtrip in the same shape as the Step 5 / Stop wrap-up — issues-delta first, grade as a footnote, then the code-gen outcome. Do **not** lead with grade movement (per [#352](https://github.com/let-sunny/canicode/issues/352)):
+
+```
+Roundtrip complete — N issues addressed, code generated:
+  ✅  X resolved
+  📝  Y annotated on Figma (referenced during code-gen)
+  🌐  Z definition writes propagated
+  ⏭️  W skipped
+  —
+  V issues remaining
+
+Grade: {oldGrade} → {newGrade}.
+Code: <files generated / next-step pointer from figma-implement-design>
+```
+
 ## Edge Cases
 
 - **No canicode MCP server**: Fall back to `npx canicode analyze --json` and `npx canicode gotcha-survey --json` — both CLI commands return the same shape as the MCP tools. The Figma MCP is still required for `use_figma` in Step 4; there is no CLI fallback for Figma design edits.
@@ -410,4 +513,4 @@ Follow the **figma-implement-design** skill workflow to generate code from the F
 - **use_figma call fails for a node**: Report the error for that specific node, continue with other nodes. Failed property modifications become annotations so the context is not lost.
 - **Re-analyze shows new issues**: Only address issues from the original gotcha survey. New issues may appear due to structural changes — report them but do not re-enter the gotcha loop.
 - **Very large design (many gotchas)**: The gotcha survey already deduplicates sibling nodes and filters to blocking/risk severity only. If there are still many questions, ask the user if they want to focus on blocking issues only.
-- **External library components**: Applies only when the orchestrator has set `allowDefinitionWrite: true`. Experiment 10's observed case is `getMainComponentAsync()` resolving with `mainComponent.remote === true` — writes then throw *"Cannot write to internal and read-only node"*. The `mainComponent === null` case is documented in the Plugin API but was not reproduced live in Experiment 10; Experiment 11 (#309) unit-test-covers the helper's routing for that branch (override-error + no `sourceChildId` → annotate with `could not apply automatically:` markdown — see ADR-011 Verification), so the code path is regression-locked while live Figma reproduction remains a manual fixture-seeding follow-up. Under the default (`allowDefinitionWrite: false`), the definition write never fires and this throw cannot surface.
+- **External library components**: Applies only when the orchestrator has set `allowDefinitionWrite: true`. Experiment 10's observed case is `getMainComponentAsync()` resolving with `mainComponent.remote === true` — writes then throw *"Cannot write to internal and read-only node"*. The `mainComponent === null` case is documented in the Plugin API but was not reproduced live in Experiment 10; Experiment 11 (#309) unit-test-covers the helper's routing for that branch (override-error + no `sourceChildId` → annotate with `could not apply automatically:` markdown — see ADR-011 Verification), so the code path is regression-locked while live Figma reproduction remains a manual fixture-seeding follow-up. Under the default (`allowDefinitionWrite: false`), the definition write never fires and this throw cannot surface. **The pre-flight `probeDefinitionWritability` (#357) detects both branches up-front** so the Definition write picker can drop the opt-in option entirely when every candidate is unwritable, saving the user a wasted decision before the runtime fallback kicks in.

package/skills/canicode-roundtrip/helpers.js

@@ -29,28 +29,39 @@ var CanICodeRoundtrip = (function (exports) {
       byLabel.set(label, created.id);
       return created.id;
     }
-    return {
+    const result = {
       gotcha: await ensure("canicode:gotcha", "blue"),
-      autoFix: await ensure("canicode:auto-fix", "green"),
+      flag: await ensure("canicode:flag", "green"),
       fallback: await ensure("canicode:fallback", "yellow")
     };
+    const legacyAutoFix = byLabel.get("canicode:auto-fix");
+    if (legacyAutoFix) result.legacyAutoFix = legacyAutoFix;
+    return result;
   }
   function upsertCanicodeAnnotation(node, input) {
     if (!node || !("annotations" in node)) return false;
     const { ruleId, markdown, categoryId, properties } = input;
-    const prefix = `**[canicode] ${ruleId}**`;
-    const body = markdown.startsWith(prefix) ? markdown : `${prefix}
+    const legacyPrefix = `**[canicode] ${ruleId}**`;
+    const footer = `\u2014 *${ruleId}*`;
+    let bodyText = markdown;
+    if (bodyText.startsWith(legacyPrefix)) {
+      bodyText = bodyText.slice(legacyPrefix.length).replace(/^\s*\n+/, "");
+    }
+    const trimmed = bodyText.replace(/\s+$/, "");
+    const body = trimmed.endsWith(footer) ? trimmed : `${trimmed}
 
-${markdown}`;
+${footer}`;
     const existing = stripAnnotations(node.annotations);
     const entry = { labelMarkdown: body };
     if (categoryId) entry.categoryId = categoryId;
     if (properties && properties.length > 0) entry.properties = properties;
-    const idx = existing.findIndex((a) => {
-      const lm = a.labelMarkdown;
-      const lb = a.label;
-      return typeof lm === "string" && lm.startsWith(prefix) || typeof lb === "string" && lb.startsWith(prefix);
-    });
+    const matchesRuleId = (text) => {
+      if (typeof text !== "string") return false;
+      return text.startsWith(legacyPrefix) || text.includes(footer);
+    };
+    const idx = existing.findIndex(
+      (a) => matchesRuleId(a.labelMarkdown) || matchesRuleId(a.label)
+    );
     if (idx >= 0) existing[idx] = entry;
     else existing.push(entry);
     try {
@@ -251,9 +262,42 @@ ${markdown}`;
     );
   }
 
+  // src/core/roundtrip/probe-definition-writability.ts
+  async function probeDefinitionWritability(questions) {
+    const verdict = /* @__PURE__ */ new Map();
+    const unwritableNames = [];
+    const seenName = /* @__PURE__ */ new Set();
+    for (const q of questions) {
+      const id = q.sourceChildId;
+      if (!id) continue;
+      if (verdict.has(id)) continue;
+      const node = await figma.getNodeByIdAsync(id);
+      const isUnwritable = node === null || node.remote === true;
+      verdict.set(id, isUnwritable ? "unwritable" : "writable");
+      if (isUnwritable) {
+        const name = typeof node?.name === "string" && node.name || q.instanceContext?.sourceComponentName || id;
+        if (!seenName.has(name)) {
+          seenName.add(name);
+          unwritableNames.push(name);
+        }
+      }
+    }
+    const totalCount = verdict.size;
+    let unwritableCount = 0;
+    for (const v of verdict.values()) if (v === "unwritable") unwritableCount++;
+    return {
+      totalCount,
+      unwritableCount,
+      unwritableSourceNames: unwritableNames,
+      allUnwritable: totalCount > 0 && unwritableCount === totalCount,
+      partiallyUnwritable: unwritableCount > 0 && unwritableCount < totalCount
+    };
+  }
+
   exports.applyPropertyMod = applyPropertyMod;
   exports.applyWithInstanceFallback = applyWithInstanceFallback;
   exports.ensureCanicodeCategories = ensureCanicodeCategories;
+  exports.probeDefinitionWritability = probeDefinitionWritability;
   exports.resolveVariableByName = resolveVariableByName;
   exports.stripAnnotations = stripAnnotations;
   exports.upsertCanicodeAnnotation = upsertCanicodeAnnotation;