@entelekheia/ref-id 0.1.2 → 0.3.0

package/dist/canonical.d.ts

@@ -0,0 +1,17 @@
+import type { ParseResult } from "./types.ts";
+/**
+ * The canonical form of an identifier: the same identifier with its qualifiers sorted by key.
+ *
+ * Sorting is by UTF-16 code unit, the order this specification already uses for its own file, and it is
+ * the cheapest canonicalisation rather than the point. What is load-bearing is that one deterministic
+ * order exists, so any two implementations reach the same answer about whether two identifiers are one.
+ *
+ * Every other part is left exactly as parsed. **Refinements are not sorted** — they sit on the fragment
+ * side and are positional, `lines=1,20` being a range, so reordering them would change what is named.
+ *
+ * A malformed identifier has no canonical form and is refused, for the reason `serialise` gives: there is
+ * no faithful way to write back a string whose failing part was never decomposed.
+ */
+export declare function canonical(identifier: string | ParseResult): string;
+/** Whether two identifiers name one thing. Order of qualifiers does not distinguish; everything else does. */
+export declare function sameIdentifier(a: string | ParseResult, b: string | ParseResult): boolean;

package/dist/canonical.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// The form two identifiers are compared in. `;a=1;b=2` and `;b=2;a=1` name one thing, so identity is
+// judged on this rather than on the bytes a producer happened to write.
+import { parse } from "./parse.js";
+import { serialise } from "./serialise.js";
+import { loadSpec, status } from "./spec.js";
+/**
+ * The canonical form of an identifier: the same identifier with its qualifiers sorted by key.
+ *
+ * Sorting is by UTF-16 code unit, the order this specification already uses for its own file, and it is
+ * the cheapest canonicalisation rather than the point. What is load-bearing is that one deterministic
+ * order exists, so any two implementations reach the same answer about whether two identifiers are one.
+ *
+ * Every other part is left exactly as parsed. **Refinements are not sorted** — they sit on the fragment
+ * side and are positional, `lines=1,20` being a range, so reordering them would change what is named.
+ *
+ * A malformed identifier has no canonical form and is refused, for the reason `serialise` gives: there is
+ * no faithful way to write back a string whose failing part was never decomposed.
+ */
+export function canonical(identifier) {
+    const spec = loadSpec();
+    const parsed = typeof identifier === "string" ? parse(identifier) : identifier;
+    if (parsed.status === status(spec, "malformed"))
+        return serialise(parsed); // throws, naming the failing part
+    const sorted = [...parsed.qualifiers].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return serialise({ ...parsed, qualifiers: sorted });
+}
+/** Whether two identifiers name one thing. Order of qualifiers does not distinguish; everything else does. */
+export function sameIdentifier(a, b) {
+    return canonical(a) === canonical(b);
+}
+//# sourceMappingURL=canonical.js.map

package/dist/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,qGAAqG;AACrG,wEAAwE;AAExE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAG5C;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAC,UAAgC;IACxD,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAA;IACvB,MAAM,MAAM,GAAG,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;IAC9E,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;QAAE,OAAO,SAAS,CAAC,MAAM,CAAC,CAAA,CAAC,kCAAkC;IAC5G,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACtF,OAAO,SAAS,CAAC,EAAE,GAAG,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAA;AACrD,CAAC;AAED,8GAA8G;AAC9G,MAAM,UAAU,cAAc,CAAC,CAAuB,EAAE,CAAuB;IAC7E,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAA;AACtC,CAAC"}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { build } from "./build.ts";
+export { canonical, sameIdentifier } from "./canonical.ts";
 export { digest } from "./digest.ts";
 export { validateEnvelope } from "./envelope.ts";
 export { BuildError, DigestError, RefIdError, SerialiseError } from "./errors.ts";

package/dist/index.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 export { build } from "./build.js";
+export { canonical, sameIdentifier } from "./canonical.js";
 export { digest } from "./digest.js";
 export { validateEnvelope } from "./envelope.js";
 export { BuildError, DigestError, RefIdError, SerialiseError } from "./errors.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAkB,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjF,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAkB,MAAM,WAAW,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entelekheia/ref-id",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "The ref: identifier scheme — a specification published as data with conformance vectors, and the package that consumes it.",
   "type": "module",
   "license": "Apache-2.0",

package/spec/ref-id.json

@@ -1,5 +1,5 @@
 {
-  "specVersion": "1.1.0",
+  "specVersion": "1.3.0",
   "scheme": "ref",
   "grammar": {
     "dialect": "ecmascript-2018",
@@ -128,6 +128,14 @@
       "declaredBy": "the agent identifier grammar namespace/name[:version]: the namespace is a domain, a platform/user under a domain, a mailbox, or the literal unknown; the ~digest of the full form is carried by state= instead",
       "corpus": "the agent bundle",
       "reference": "dot-agent agent-id reference"
+    },
+    "ai-model": {
+      "locator": "served-model-id",
+      "validator": "declared-name",
+      "delegate": "verbatim",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:@-]*(?:/[A-Za-z0-9][A-Za-z0-9._:@-]*)*$",
+      "declaredBy": "the id the model is served under — the exact string a caller sends to the serving process to select it, verbatim. Deliberately permissive: coercing a served name breaks the round-trip that makes it an identifier at all, so ':' (an Ollama tag), '/' (a hub-style namespace) and '@' (an LM Studio quantisation key, a revision pin) are all admitted, because a serving process accepts each of them today and rejecting one would be a defect rather than a safeguard. Every '/'-separated segment must open on an alphanumeric, which admits each of those and excludes '..', '//' and a trailing '/': the delegate is verbatim, so a consumer mapping a served id onto a path — a local weights cache — would otherwise inherit a traversal from a locator that parsed clean. Case is significant and there is no normalisation, which is a decision with no way back: two callers naming one model in two casings mint two identifiers, and adding a fold later would be a change to normalisation, which mints identifier version 2.",
+      "reference": "no published grammar names a hosted API model: Package URL registers artifact-registry namespaces only (huggingface, mlflow), CycloneDX carries the category as a component type and identifies with an ordinary purl, SPDX 3.0's AIPackage identifies by free-text name and delegates to packageUrl, and OpenTelemetry's gen_ai.request.model is explicitly free text — so this type is this specification's own, not a delegation."
     }
   },
   "typeRegistry": "a type names the naming system that owns the locator grammar; an unregistered type parses to uncovered, never to malformed, and registering its validator here is what promotes it — the registry is this table",
@@ -190,7 +198,8 @@
       "role": "population",
       "forms": [
         "ref",
-        "sha256"
+        "sha256",
+        "unknown"
       ]
     },
     "when": {
@@ -229,6 +238,10 @@
       "nested": true,
       "depth": 1,
       "encoding": "nested"
+    },
+    "unknown": {
+      "pattern": "^unknown$",
+      "reference": "the declared level for a population nobody established. Deliberately not `none`, which `state` uses: a state cannot be empty, so `none` is unambiguous there, while a population over zero members is a real and different thing from a population nobody recorded — and an identifier must not let the two read alike. It is a floor, never a destination: a producer that can enumerate its population says so with `sha256`, which names which population rather than admitting there was one"
     }
   },
   "refinements": {
@@ -288,6 +301,14 @@
     "dedupe": false,
     "output": "sha256:<64 lowercase hex>"
   },
+  "identifierEquivalence": {
+    "qualifierOrder": "insignificant",
+    "refinementOrder": "significant",
+    "canonicalForm": "re-serialise the parsed identifier with its qualifiers sorted by key in UTF-16 code unit order; every other part verbatim, refinements included",
+    "comparison": "two identifiers name one thing when their canonical forms are equal byte for byte",
+    "reserialisation": "SHOULD preserve the order written; MUST NOT be relied on to tell two identifiers apart",
+    "note": "distinct from `canonicalisation`, which is the form of THIS FILE for its own digest"
+  },
   "canonicalisation": {
     "form": "json-sorted-keys-compact",
     "rules": [
@@ -1127,6 +1148,316 @@
           "status": "malformed",
           "part": "locator"
         }
+      },
+      {
+        "name": "ai-model served id is admitted: Qwen3-4B-Instruct-2507-4bit",
+        "input": "ref:ai-model:Qwen3-4B-Instruct-2507-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "Qwen3-4B-Instruct-2507-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: gemma-4-26b-a4b-it-4bit",
+        "input": "ref:ai-model:gemma-4-26b-a4b-it-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "gemma-4-26b-a4b-it-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: Qwen3.5-9B-OptiQ-4bit",
+        "input": "ref:ai-model:Qwen3.5-9B-OptiQ-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "Qwen3.5-9B-OptiQ-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: gpt-oss-20b-MXFP4-Q8",
+        "input": "ref:ai-model:gpt-oss-20b-MXFP4-Q8",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "gpt-oss-20b-MXFP4-Q8"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: Llama-3.2-1B-Instruct-4bit",
+        "input": "ref:ai-model:Llama-3.2-1B-Instruct-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "Llama-3.2-1B-Instruct-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: Qwen3.5-27B-Claude-4.6-Opus-Distilled-MLX-4bit",
+        "input": "ref:ai-model:Qwen3.5-27B-Claude-4.6-Opus-Distilled-MLX-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "Qwen3.5-27B-Claude-4.6-Opus-Distilled-MLX-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: SmolLM3-3B-4bit",
+        "input": "ref:ai-model:SmolLM3-3B-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "SmolLM3-3B-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: T-mixed-gemma-4-12B-it-OptiQ-4bit",
+        "input": "ref:ai-model:T-mixed-gemma-4-12B-it-OptiQ-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "T-mixed-gemma-4-12B-it-OptiQ-4bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: claude-opus-5",
+        "input": "ref:ai-model:claude-opus-5",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "claude-opus-5"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: Ternary-Bonsai-27B-mlx-2bit",
+        "input": "ref:ai-model:Ternary-Bonsai-27B-mlx-2bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "Ternary-Bonsai-27B-mlx-2bit"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: gemini-2.5-flash",
+        "input": "ref:ai-model:gemini-2.5-flash",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "gemini-2.5-flash"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: llama3:8b",
+        "input": "ref:ai-model:llama3:8b",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "llama3:8b"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: gpt-4o-2024-08-06",
+        "input": "ref:ai-model:gpt-4o-2024-08-06",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "gpt-4o-2024-08-06"
+        }
+      },
+      {
+        "name": "ai-model served id is admitted: mlx-community/Qwen3-1.7B-4bit",
+        "input": "ref:ai-model:mlx-community/Qwen3-1.7B-4bit",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [],
+          "fragment": null,
+          "type": "ai-model",
+          "locator": "mlx-community/Qwen3-1.7B-4bit"
+        }
+      },
+      {
+        "name": "an ai-model id cannot open on a separator",
+        "input": "ref:ai-model:-Qwen3-4B",
+        "expect": {
+          "status": "malformed",
+          "part": "locator"
+        }
+      },
+      {
+        "name": "unknown is a declared population level",
+        "input": "ref:folder:acme-tools;over=unknown",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "qualifiers": [
+            [
+              "over",
+              "unknown"
+            ]
+          ],
+          "fragment": null,
+          "type": "folder",
+          "locator": "acme-tools"
+        }
+      },
+      {
+        "name": "none is not a population level — a population of zero is not a population nobody recorded",
+        "input": "ref:folder:acme-tools;over=none",
+        "expect": {
+          "status": "malformed",
+          "part": "over"
+        }
+      },
+      {
+        "name": "unknown is not a state level — the fence from the other side",
+        "input": "ref:folder:acme-tools;state=unknown",
+        "expect": {
+          "status": "malformed",
+          "part": "state"
+        }
+      },
+      {
+        "name": "unknown is declared for over alone, never for by",
+        "input": "ref:folder:acme-tools;by=unknown",
+        "expect": {
+          "status": "malformed",
+          "part": "by"
+        }
+      },
+      {
+        "name": "an ai-model id cannot carry a character outside its declared class",
+        "input": "ref:ai-model:a b",
+        "expect": {
+          "status": "malformed",
+          "part": "locator"
+        }
+      },
+      {
+        "name": "an ai-model id carries a quantisation key after @",
+        "input": "ref:ai-model:qwen2.5-7b-instruct@q4_k_m",
+        "expect": {
+          "status": "ok",
+          "version": 1,
+          "type": "ai-model",
+          "locator": "qwen2.5-7b-instruct@q4_k_m",
+          "qualifiers": [],
+          "fragment": null
+        }
+      },
+      {
+        "name": "an ai-model id cannot traverse — every segment opens on an alphanumeric",
+        "input": "ref:ai-model:a/../../etc/passwd",
+        "expect": {
+          "status": "malformed",
+          "part": "locator"
+        }
+      },
+      {
+        "name": "an ai-model id cannot carry an empty segment",
+        "input": "ref:ai-model:a//b",
+        "expect": {
+          "status": "malformed",
+          "part": "locator"
+        }
+      }
+    ],
+    "canonical": [
+      {
+        "name": "one qualifier is already canonical",
+        "input": "ref:eita:structured-output@1/validity;when=2026-08-02T18:31:31.870Z",
+        "expect": "ref:eita:structured-output@1/validity;when=2026-08-02T18:31:31.870Z"
+      },
+      {
+        "name": "two qualifiers written out of order sort by key",
+        "input": "ref:eita:structured-output@1/validity;when=2026-08-02T18:31:31.870Z;over=unknown",
+        "expect": "ref:eita:structured-output@1/validity;over=unknown;when=2026-08-02T18:31:31.870Z"
+      },
+      {
+        "name": "the same qualifiers in the other order reach the same form",
+        "input": "ref:eita:structured-output@1/validity;over=unknown;when=2026-08-02T18:31:31.870Z",
+        "expect": "ref:eita:structured-output@1/validity;over=unknown;when=2026-08-02T18:31:31.870Z"
+      },
+      {
+        "name": "an unknown key sorts beside a declared one, carried through",
+        "input": "ref:eita:citation-fidelity@1/exact;when=2026-08-14T23:38:26.089Z;context-tokens=8000;over=unknown",
+        "expect": "ref:eita:citation-fidelity@1/exact;context-tokens=8000;over=unknown;when=2026-08-14T23:38:26.089Z"
+      },
+      {
+        "name": "sorting is by UTF-16 code unit, so a hyphen precedes a letter",
+        "input": "ref:eita:t@1/o;alphaone=1;alpha-two=2;alpha=3",
+        "expect": "ref:eita:t@1/o;alpha=3;alpha-two=2;alphaone=1"
+      },
+      {
+        "name": "a nested value is not decoded by canonicalisation",
+        "input": "ref:eita:t@1/o;when=2026-08-02T18:31:31.870Z;over=ref:ai-model:Qwen3-4B-Instruct-2507-4bit",
+        "expect": "ref:eita:t@1/o;over=ref:ai-model:Qwen3-4B-Instruct-2507-4bit;when=2026-08-02T18:31:31.870Z"
+      },
+      {
+        "name": "no qualifiers, nothing to sort",
+        "input": "ref:pkg:npm/@acme/scanner-core@0.1.0#Observation",
+        "expect": "ref:pkg:npm/@acme/scanner-core@0.1.0#Observation"
+      },
+      {
+        "name": "an explicit version survives canonicalisation verbatim",
+        "input": "ref:1:pkg:npm/x@1.0.0;state=none;by=sha256:0000000000000000000000000000000000000000000000000000000000000000",
+        "expect": "ref:1:pkg:npm/x@1.0.0;by=sha256:0000000000000000000000000000000000000000000000000000000000000000;state=none"
+      },
+      {
+        "name": "refinements are positional and keep the order they were written",
+        "input": "ref:folder:acme-governance;state=none#AGENTS.md;lines=1,20;item=3",
+        "expect": "ref:folder:acme-governance;state=none#AGENTS.md;lines=1,20;item=3"
+      },
+      {
+        "name": "qualifiers sort while the fragment beside them is untouched",
+        "input": "ref:folder:acme-governance;when=2026-08-02T18:31:31.870Z;state=none#AGENTS.md;lines=1,20",
+        "expect": "ref:folder:acme-governance;state=none;when=2026-08-02T18:31:31.870Z#AGENTS.md;lines=1,20"
+      },
+      {
+        "name": "a malformed identifier has no canonical form",
+        "input": "ref:eita:t@1/o;state=none;state=none",
+        "expect": { "error": "state" }
       }
     ],
     "roundtrip": [
@@ -1149,7 +1480,10 @@
       "ref:pkg:npm/acme-tools#acme/adr@2/0019",
       "ref:folder:acme-tools;by=ref:2:pkg:npm/x@1.0.0",
       "ref:doi:10.1000/182;state=swh:1:rev:7e29bb6000000000000000000000000000000000#S",
-      "ref:folder:acme-tools;by=ref:pkg:npm/x@1.0.0%2523src/y"
+      "ref:folder:acme-tools;by=ref:pkg:npm/x@1.0.0%2523src/y",
+      "ref:ai-model:mlx-community/Qwen3-1.7B-4bit",
+      "ref:ai-model:llama3:8b",
+      "ref:folder:acme-tools;over=unknown"
     ],
     "build": [
       {
@@ -1300,6 +1634,36 @@
           ]
         },
         "expect": "ref:folder:acme-tools;over=sha256:41b9caaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+      },
+      {
+        "name": "an ai-model locator with a hub-style separator builds as is",
+        "parts": {
+          "type": "ai-model",
+          "locator": "mlx-community/Qwen3-1.7B-4bit"
+        },
+        "expect": "ref:ai-model:mlx-community/Qwen3-1.7B-4bit"
+      },
+      {
+        "name": "an ai-model locator with an Ollama tag builds as is",
+        "parts": {
+          "type": "ai-model",
+          "locator": "llama3:8b"
+        },
+        "expect": "ref:ai-model:llama3:8b"
+      },
+      {
+        "name": "over=unknown builds as the declared level for an unestablished population",
+        "parts": {
+          "type": "folder",
+          "locator": "acme-tools",
+          "qualifiers": [
+            [
+              "over",
+              "unknown"
+            ]
+          ]
+        },
+        "expect": "ref:folder:acme-tools;over=unknown"
       }
     ],
     "digest": [

package/spec/ref-id.json.sha256

@@ -1 +1 @@
-c58f36a43416e5422235e8d92920d4d82581601deed69169901291938c5e2727
+d10d07be0fbf02acef1717de1945ec4a2e2ceef954f80017051127a1c0fb3b0a