@dtmd/temper 0.0.15 → 0.0.16

package/dist/src/builtins.d.ts

@@ -907,10 +907,11 @@ export declare const hookDefaultContract: readonly Clause[];
  * verifier names (`contract.ts`'s `telemetry`, the `roster.rs` admissibility set); the
  * `event` is the `hooks.<Event>` key the tap registers under, and the `matcher` scopes
  * the fire to the telemetry-relevant subset — each an external fact
- * (code.claude.com/docs/en/hooks, retrieved 2026-07-17):
+ * (code.claude.com/docs/en/hooks, retrieved 2026-08-26):
  *
  * - `InstructionsLoaded` fires on a rule/memory load; its matcher filters the load
- *   reason, and `path_glob_match` is the lazy per-path load the coverage tap reads.
+ *   reason across all documented reasons (session_start, nested_traversal, path_glob_match,
+ *   include, compact), so always-on members that load at session start are recorded.
  * - `SkillInvoked` is a skill invocation, surfaced under `PostToolUse` with the tool-name
  *   matcher `Skill` — the tap's own read of a skill call.
  * - `UserPromptExpansion` fires on a command expansion; its matcher filters the command

package/dist/src/builtins.js

@@ -756,6 +756,11 @@ export const skillDefaultContract = [
         guidance: "The optional `paths` scope gates every invocation channel until Claude reads a file its globs match; each entry is a glob (brace expansion supported). An unparseable pattern — an unclosed `[`, say — is invalid under globset and silently matches nothing, so the gate never opens and the skill never registers, with no error surfaced. Fix the pattern or drop the field.",
         cite: "https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-15)",
     }),
+    clause(mentionReachable("paths", "paths"), {
+        severity: "advisory",
+        guidance: "A mention of a gated member is actionable only where that member can be invoked. A `paths` gate removes its member from every invocation channel until Claude reads a matching file, and invoking a gated member from outside its gate hard-errors (`Unknown skill`) — the harness then tells the user it doesn't exist. So a skill that loads where its target cannot be invoked hands Claude an obligation it cannot act on. Two remedies: scope this skill's `paths` to the target's gate, or ungate the target. Advisory because the containment test is literal — every glob here must appear verbatim in the gate — so a semantically narrower glob (`src/**/*.ts` inside `src/**`) false-fires; retune or drop this clause in your own contract when it does.",
+        cite: "https://code.claude.com/docs/en/skills (retrieved 2026-07-16; gating hard-error verified against 2.1.211)",
+    }),
 ];
 /**
  * The default contract for `supporting-doc` — one clause, because the format documents
@@ -951,10 +956,11 @@ export const hookDefaultContract = [
  * verifier names (`contract.ts`'s `telemetry`, the `roster.rs` admissibility set); the
  * `event` is the `hooks.<Event>` key the tap registers under, and the `matcher` scopes
  * the fire to the telemetry-relevant subset — each an external fact
- * (code.claude.com/docs/en/hooks, retrieved 2026-07-17):
+ * (code.claude.com/docs/en/hooks, retrieved 2026-08-26):
  *
  * - `InstructionsLoaded` fires on a rule/memory load; its matcher filters the load
- *   reason, and `path_glob_match` is the lazy per-path load the coverage tap reads.
+ *   reason across all documented reasons (session_start, nested_traversal, path_glob_match,
+ *   include, compact), so always-on members that load at session start are recorded.
  * - `SkillInvoked` is a skill invocation, surfaced under `PostToolUse` with the tool-name
  *   matcher `Skill` — the tap's own read of a skill call.
  * - `UserPromptExpansion` fires on a command expansion; its matcher filters the command
@@ -963,7 +969,7 @@ export const hookDefaultContract = [
  *   capturing every one.
  */
 export const TELEMETRY_EVENT_HOOKS = {
-    InstructionsLoaded: { event: "InstructionsLoaded", matcher: "path_glob_match" },
+    InstructionsLoaded: { event: "InstructionsLoaded", matcher: ".*" },
     SkillInvoked: { event: "PostToolUse", matcher: "Skill" },
     UserPromptExpansion: { event: "UserPromptExpansion", matcher: ".*" },
     ToolUse: { event: "PostToolUse", matcher: ".*" },

package/dist/src/declarations.d.ts

@@ -13,6 +13,15 @@ import type { Declarations, Payload, RegistrationRow, SettingsRow } from "./gene
 export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./generated/index.js";
 /** The stable-sort ordering every declaration row family shares. */
 export declare function compareStrings(a: string, b: string): number;
+/**
+ * Build a `Map<K, V>` from an iterable of key-value pairs, refusing on duplicate
+ * identity keys. A map the caller builds must have unique keys; a duplicate is
+ * corruption, not a shadowing rule.
+ *
+ * @throws Error when a key appears more than once in the iterable, naming the
+ * colliding key.
+ */
+export declare function uniqueMap<K, V>(entries: Iterable<[K, V]>): Map<K, V>;
 /**
  * One composed embedded value's key in an {@link EdgePlacements} table — its host's
  * `kind:name` address plus the value's own kind and key, the same triple the

package/dist/src/declarations.js

@@ -162,6 +162,24 @@ function registrationLabels(registration) {
 export function compareStrings(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }
+/**
+ * Build a `Map<K, V>` from an iterable of key-value pairs, refusing on duplicate
+ * identity keys. A map the caller builds must have unique keys; a duplicate is
+ * corruption, not a shadowing rule.
+ *
+ * @throws Error when a key appears more than once in the iterable, naming the
+ * colliding key.
+ */
+export function uniqueMap(entries) {
+    const map = new Map();
+    for (const [key, value] of entries) {
+        if (map.has(key)) {
+            throw new Error(`duplicate identity key \`${key}\``);
+        }
+        map.set(key, value);
+    }
+    return map;
+}
 /**
  * A host kind's nesting templates, from its two declaration loci. The kind's own
  * declared templates carry each layer — child kind, plus a file layer's path pattern.
@@ -309,24 +327,16 @@ function kindFactKindsInPlay(allKinds) {
 }
 /** The requirement rows — assembly `require` and every member's `requires`, one namespace. */
 function requirementRows(harness) {
-    const merged = new Map();
-    const publish = (name, requirement, source) => {
-        const existing = merged.get(name);
-        if (existing !== undefined && existing !== requirement) {
-            // One namespace, one fill mechanism; a cross-publisher name collision is an
-            // admissibility finding, never a shadowing rule.
-            throw new Error(`requirement \`${name}\` is published twice (${source} collides with an earlier ` +
-                `publisher) — a name collision across publishers is an admissibility finding.`);
-        }
-        merged.set(name, requirement);
-    };
-    for (const [name, requirement] of Object.entries(harness.require))
-        publish(name, requirement, "the assembly");
+    const entries = [];
+    for (const [name, requirement] of Object.entries(harness.require)) {
+        entries.push([name, requirement]);
+    }
     for (const member of harness.members) {
         for (const [name, requirement] of Object.entries(member.requires)) {
-            publish(name, requirement, `member \`${member.name}\``);
+            entries.push([name, requirement]);
         }
     }
+    const merged = uniqueMap(entries);
     return [...merged.entries()]
         .sort(([a], [b]) => compareStrings(a, b))
         .map(([name, requirement]) => ({
@@ -632,7 +642,7 @@ export function registrationRows(harness) {
 /** The tap invocation the synthesized telemetry hooks run — the sibling verb of the
  * session-start reporter, appending one event record to the per-machine log
  * (`src/tap.rs`). Every synthesized hook's `command` field carries it verbatim. */
-const TAP_COMMAND = "temper tap";
+const TAP_COMMAND = "temper tap \"$CLAUDE_PROJECT_DIR\"";
 /**
  * Builds a collision-safe dedup key for a tap hook (event, matcher) pair.
  * Two distinct pairs cannot produce the same key (e.g., ("Foo", "BarBaz") ≠ ("FooBar", "Baz")).

package/dist/src/emit.js

@@ -12,7 +12,7 @@ import { fileURLToPath } from "node:url";
 import { readFileSync } from "node:fs";
 import { checkMentions, isTextSpan, renderText, resolveLeaf } from "./prose.js";
 import { permissionUnion } from "./needs.js";
-import { compareStrings, compileDeclarations, declaredAddresses, declaredAtLocusKinds, declaredRequirements, encodeSeam, placementKey, registrationRows, settingsRows, tapHookRows, } from "./declarations.js";
+import { compareStrings, compileDeclarations, declaredAddresses, declaredAtLocusKinds, declaredRequirements, encodeSeam, placementKey, registrationRows, settingsRows, tapHookRows, uniqueMap, } from "./declarations.js";
 /** The {@link MentionScope} a set of {@link ResolveOptions} names — its two sets, each defaulting to empty. */
 function scopeOf(options) {
     return {
@@ -209,6 +209,7 @@ function edgeTargetFacts(host, value, leaves, options) {
             address: lookup,
             kind: target.kind,
             path: relativeProjection(projectionPath(host), projectionPath(target)),
+            repoRootedPath: projectionPath(target),
         };
     }
     return targets;
@@ -349,7 +350,7 @@ function placedEdges(host, value, options) {
  * values `nestedMemberRows` does, so every edge-bearing row it builds has an observation.
  */
 function edgePlacements(harness, options) {
-    const placements = new Map();
+    const entries = [];
     for (const member of harness.members) {
         if (member.prose?.kind !== "blocks")
             continue;
@@ -358,11 +359,11 @@ function edgePlacements(harness, options) {
                 continue;
             const placed = placedEdges(member, value, options);
             if (placed !== undefined) {
-                placements.set(placementKey(`${member.kind}:${member.name}`, value.kind, value.key), placed);
+                entries.push([placementKey(`${member.kind}:${member.name}`, value.kind, value.key), placed]);
             }
         }
     }
-    return placements;
+    return uniqueMap(entries);
 }
 /**
  * The line count of a rendered block, matching the engine's `str::lines()`: a single
@@ -390,7 +391,7 @@ function renderedLineCount(block) {
  * distinction between an observed empty and an unobserved absence).
  */
 function renderedExtents(harness, options) {
-    const extents = new Map();
+    const entries = [];
     for (const member of harness.members) {
         if (member.prose?.kind !== "blocks")
             continue;
@@ -398,15 +399,18 @@ function renderedExtents(harness, options) {
             if (isTextSpan(value))
                 continue;
             const block = renderMemberBlock(member, value, options);
-            extents.set(placementKey(`${member.kind}:${member.name}`, value.kind, value.key), {
-                lines: renderedLineCount(block),
-                // Unicode scalar values, matching Rust's `chars().count()` — iterating a string
-                // yields code points, so a surrogate pair counts once, the way it does file-side.
-                chars: [...block].length,
-            });
+            entries.push([
+                placementKey(`${member.kind}:${member.name}`, value.kind, value.key),
+                {
+                    lines: renderedLineCount(block),
+                    // Unicode scalar values, matching Rust's `chars().count()` — iterating a string
+                    // yields code points, so a surrogate pair counts once, the way it does file-side.
+                    chars: [...block].length,
+                },
+            ]);
         }
     }
-    return extents;
+    return uniqueMap(entries);
 }
 /**
  * Render a member-level `Text` body to its final bytes: its mentions are
@@ -550,7 +554,7 @@ function settingsResidue(harness) {
  * spells a member address, so an edge field and a mention name a member the same way.
  */
 function memberTable(harness) {
-    return new Map(harness.members.map((member) => [`${member.kind}:${member.name}`, member]));
+    return uniqueMap(harness.members.map((member) => [`${member.kind}:${member.name}`, member]));
 }
 /** The harness's projected members as payload members, deterministically kind-then-name ordered. */
 function orderedMembers(harness, options) {

package/dist/src/kind.d.ts

@@ -345,8 +345,7 @@ export interface ResolvedEmbeddedMemberCollectionEntry {
  * The closed set of facts an embedded format may place about one edge field's
  * target — derived at emit off the resolved target member, never authored at the
  * instance and never fabricated, so a rendered reference is true by construction.
- * The set is exactly these four; a fifth fact is a spec question, not a
- * convenience.
+ * The set is exactly these five facts; no convenience additions beyond.
  */
 export interface EdgeTargetFacts {
     /** The target member's identity within its kind. */
@@ -355,8 +354,10 @@ export interface EdgeTargetFacts {
     readonly address: string;
     /** The target member's kind. */
     readonly kind: string;
-    /** The target's projection, relative to the host member's own projection. */
+    /** The target's projection, relative to the host member's own projection — used by a render hook to spell a link from the host body. */
     readonly path: string;
+    /** The target's projection rooted at the repository — used by a render hook consuming edge targets from repo root. */
+    readonly repoRootedPath: string;
 }
 /**
  * An {@link EmbeddedMemberValue} after every leaf (top-level and each

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "The temper authoring face — the six-noun model as typed modules: harness(), kind<T>(), clause values, needs, and file()/text/blocks(). Emit compiles to the declaration rows the engine reads, a byte-faithful projection, and the lock.",
   "license": "(MIT OR Apache-2.0)",
   "repository": {
@@ -52,7 +52,7 @@
     "temper": "bin/temper.js"
   },
   "optionalDependencies": {
-    "@dtmd/temper-linux-x64": "0.0.15",
-    "@dtmd/temper-win32-x64": "0.0.15"
+    "@dtmd/temper-linux-x64": "0.0.16",
+    "@dtmd/temper-win32-x64": "0.0.16"
   }
 }