capdag 0.126.278 → 0.127.280

package/capdag.js

@@ -789,18 +789,22 @@ const MEDIA_OBJECT = 'media:record';
 // Media URN for binary data - the most general media type (no constraints)
 const MEDIA_IDENTITY = 'media:';
 
-// Array types - URNs must match base.toml definitions
-// Media URN for string array type - textable with list marker
-const MEDIA_STRING_ARRAY = 'media:list;textable';
-// Media URN for integer array type - textable, numeric with list marker
-const MEDIA_INTEGER_ARRAY = 'media:integer;list;textable;numeric';
-// Media URN for number array type - textable, numeric with list marker
-const MEDIA_NUMBER_ARRAY = 'media:list;textable;numeric';
-// Media URN for boolean array type - uses "bool" with list marker
-const MEDIA_BOOLEAN_ARRAY = 'media:bool;list;textable';
-// Media URN for object array type - list of records (NOT textable)
-// Use a specific format like JSON array for textable object arrays.
-const MEDIA_OBJECT_ARRAY = 'media:list;record';
+// List types - URNs must match base.toml definitions
+// Media URN for generic list type
+const MEDIA_LIST = 'media:list';
+// Media URN for textable list type
+const MEDIA_TEXTABLE_LIST = 'media:list;textable';
+// Media URN for string list type - textable with list marker
+const MEDIA_STRING_LIST = 'media:list;textable';
+// Media URN for integer list type - textable, numeric with list marker
+const MEDIA_INTEGER_LIST = 'media:integer;list;textable;numeric';
+// Media URN for number list type - textable, numeric with list marker
+const MEDIA_NUMBER_LIST = 'media:list;numeric;textable';
+// Media URN for boolean list type - uses "bool" with list marker
+const MEDIA_BOOLEAN_LIST = 'media:bool;list;textable';
+// Media URN for object list type - list of records (NOT textable)
+// Use a specific format like JSON array for textable object lists.
+const MEDIA_OBJECT_LIST = 'media:list;record';
 
 // Semantic media types for specialized content
 // Media URN for PNG image data
@@ -813,8 +817,6 @@ const MEDIA_VIDEO = 'media:video';
 // Semantic AI input types - distinguished by their purpose/context
 // Media URN for audio input containing speech for transcription (Whisper)
 const MEDIA_AUDIO_SPEECH = 'media:audio;wav;speech';
-// Media URN for thumbnail image output
-const MEDIA_IMAGE_THUMBNAIL = 'media:image;png;thumbnail';
 
 // Document types (PRIMARY naming - type IS the format)
 // Media URN for PDF documents
@@ -842,6 +844,18 @@ const MEDIA_JSON_SCHEMA = 'media:json;json-schema;record;textable';
 // Media URN for YAML data - has record marker (structured key-value)
 const MEDIA_YAML = 'media:record;textable;yaml';
 
+// Format-specific variants for JSON, YAML, CSV
+const MEDIA_JSON_VALUE = 'media:json;textable';
+const MEDIA_JSON_RECORD = 'media:json;record;textable';
+const MEDIA_JSON_LIST = 'media:json;list;textable';
+const MEDIA_JSON_LIST_RECORD = 'media:json;list;record;textable';
+const MEDIA_YAML_VALUE = 'media:textable;yaml';
+const MEDIA_YAML_RECORD = 'media:record;textable;yaml';
+const MEDIA_YAML_LIST = 'media:list;textable;yaml';
+const MEDIA_YAML_LIST_RECORD = 'media:list;record;textable;yaml';
+const MEDIA_CSV = 'media:csv;list;record;textable';
+const MEDIA_CSV_LIST = 'media:csv;list;textable';
+
 // File path types - for arguments that represent filesystem paths
 // Media URN for a single file path - textable, scalar by default (no list marker)
 const MEDIA_FILE_PATH = 'media:file-path;textable';
@@ -849,8 +863,6 @@ const MEDIA_FILE_PATH = 'media:file-path;textable';
 const MEDIA_FILE_PATH_ARRAY = 'media:file-path;list;textable';
 
 // Semantic text input types - distinguished by their purpose/context
-// Media URN for frontmatter text (book metadata) - scalar by default
-const MEDIA_FRONTMATTER_TEXT = 'media:frontmatter;textable';
 // Media URN for model spec (provider:model format, HuggingFace name, etc.) - scalar by default
 const MEDIA_MODEL_SPEC = 'media:model-spec;textable';
 // Media URN for MLX model path - scalar by default
@@ -877,20 +889,17 @@ const MEDIA_PATH_OUTPUT = 'media:model-path;record;textable';
 const MEDIA_EMBEDDING_VECTOR = 'media:embedding-vector;record;textable';
 // Media URN for LLM inference output - has record marker
 const MEDIA_LLM_INFERENCE_OUTPUT = 'media:generated-text;record;textable';
-// Media URN for extracted metadata - has record marker
-const MEDIA_FILE_METADATA = 'media:file-metadata;record;textable';
-// Media URN for extracted outline - has record marker
-const MEDIA_DOCUMENT_OUTLINE = 'media:document-outline;record;textable';
-// Media URN for disbound page - has list marker (array of page objects)
-const MEDIA_DISBOUND_PAGE = 'media:disbound-page;list;textable';
 // Media URN for vision inference output - textable, scalar by default
 const MEDIA_IMAGE_DESCRIPTION = 'media:image-description;textable';
 // Media URN for transcription output - has record marker
 const MEDIA_TRANSCRIPTION_OUTPUT = 'media:record;textable;transcription';
-// Media URN for decision output (bit choice) - scalar by default
-const MEDIA_DECISION = 'media:bool;decision;textable';
-// Media URN for decision array output (bit choices) - has list marker
-const MEDIA_DECISION_ARRAY = 'media:bool;decision;list;textable';
+// Media URN for decision output - JSON record with textable
+const MEDIA_DECISION = 'media:decision;json;record;textable';
+// Media URN for textable page output
+const MEDIA_TEXTABLE_PAGE = 'media:textable;page';
+// Collection types
+const MEDIA_COLLECTION = 'media:collection;record';
+const MEDIA_COLLECTION_LIST = 'media:collection;list;record';
 
 // =============================================================================
 // STANDARD CAP URN CONSTANTS
@@ -956,8 +965,10 @@ class MediaUrn {
   // =========================================================================
 
   /**
-   * Returns true if this media is a list (has `list` marker tag).
-   * Returns false if scalar (no `list` marker = default).
+   * Returns true if this media URN describes list-type data (has `list` marker tag).
+   * This is a semantic type check — it means "the data format IS a list/array".
+   * This does NOT indicate input cardinality (single vs multiple items).
+   * Cardinality is tracked by is_sequence on the wire protocol, not by URN tags.
    * @returns {boolean}
    */
   isList() { return this._hasMarkerTag('list'); }
@@ -1027,6 +1038,22 @@ class MediaUrn {
   /** @returns {boolean} True if the "bool" marker tag is present */
   isBool() { return this._urn.getTag('bool') !== undefined; }
 
+  /**
+   * Returns true if this media URN describes YAML representation.
+   * @returns {boolean}
+   */
+  isYaml() {
+    return this._hasMarkerTag('yaml');
+  }
+
+  /**
+   * Returns true if this media URN describes CSV representation.
+   * @returns {boolean}
+   */
+  isCsv() {
+    return this._hasMarkerTag('csv');
+  }
+
   /**
    * Check if this represents a single file path type (not array).
    * Returns true if the "file-path" marker tag is present AND no list marker.
@@ -1048,6 +1075,13 @@ class MediaUrn {
    */
   isAnyFilePath() { return this._hasMarkerTag('file-path'); }
 
+  /**
+   * Check if this represents a collection type.
+   * Returns true if the "collection" marker tag is present.
+   * @returns {boolean}
+   */
+  isCollection() { return this._hasMarkerTag('collection'); }
+
   /**
    * Check if this media URN conforms to another (pattern).
    * @param {MediaUrn} pattern
@@ -1123,20 +1157,67 @@ class MediaUrn {
 // =============================================================================
 
 /**
- * Build URN for LLM conversation capability
- * @param {string} langCode - Language code (e.g., "en", "fr")
+ * Build URN for LLM generate-text capability
  * @returns {CapUrn}
  */
-function llmConversationUrn(langCode) {
+function llmGenerateTextUrn() {
   return new CapUrnBuilder()
-    .tag('op', 'conversation')
-    .tag('unconstrained', '*')
-    .tag('language', langCode)
+    .tag('op', 'generate_text')
+    .tag('llm', '*')
+    .tag('ml-model', '*')
     .inSpec(MEDIA_STRING)
-    .outSpec(MEDIA_LLM_INFERENCE_OUTPUT)
+    .outSpec(MEDIA_STRING)
+    .build();
+}
+
+/**
+ * Build URN for render-page-image capability
+ * @param {string} inputMedia - The input media URN string
+ * @returns {CapUrn}
+ */
+function renderPageImageUrn(inputMedia) {
+  return new CapUrnBuilder()
+    .tag('op', 'render_page_image')
+    .inSpec(inputMedia)
+    .outSpec(MEDIA_PNG)
+    .build();
+}
+
+/**
+ * Build URN for format conversion capability
+ * @param {string} inMedia - The input media URN string
+ * @param {string} outMedia - The output media URN string
+ * @returns {CapUrn}
+ */
+function formatConversionUrn(inMedia, outMedia) {
+  return new CapUrnBuilder()
+    .tag('op', 'convert_format')
+    .inSpec(inMedia)
+    .outSpec(outMedia)
     .build();
 }
 
+/**
+ * Map a primitive type name to the corresponding media URN string.
+ * @param {string} typeName - The type name (e.g., 'string', 'integer', 'string-list')
+ * @returns {string|null} The media URN string, or null if not recognized
+ */
+function mediaUrnForType(typeName) {
+  switch (typeName) {
+    case 'string': return MEDIA_STRING;
+    case 'integer': return MEDIA_INTEGER;
+    case 'number': return MEDIA_NUMBER;
+    case 'boolean': return MEDIA_BOOLEAN;
+    case 'object': return MEDIA_OBJECT;
+    case 'string-list': return MEDIA_STRING_LIST;
+    case 'integer-list': return MEDIA_INTEGER_LIST;
+    case 'number-list': return MEDIA_NUMBER_LIST;
+    case 'boolean-list': return MEDIA_BOOLEAN_LIST;
+    case 'object-list': return MEDIA_OBJECT_LIST;
+    default: return null;
+  }
+}
+
 /**
  * Build URN for model-availability capability
  * @returns {CapUrn}
@@ -2933,6 +3014,56 @@ class CapValidator {
 // CAP ARGUMENT VALUE - Unified argument type
 // ============================================================================
 
+/**
+ * Result from a cap execution.
+ *
+ * Scalar outputs carry raw materialized bytes (e.g. UTF-8 text, raw binary).
+ * List outputs carry a CBOR sequence of values, one per list item.
+ * Empty represents a void cap with no output.
+ */
+class CapResult {
+  static KIND_SCALAR = 'scalar';
+  static KIND_LIST = 'list';
+  static KIND_EMPTY = 'empty';
+
+  /**
+   * @param {'scalar'|'list'|'empty'} kind
+   * @param {Uint8Array|null} data - Bytes for scalar or CBOR sequence for list, null for empty
+   */
+  constructor(kind, data = null) {
+    this.kind = kind;
+    this.data = data;
+  }
+
+  /** Create a CapResult carrying raw bytes (scalar output). */
+  static scalar(data) {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data || []);
+    return new CapResult(CapResult.KIND_SCALAR, bytes);
+  }
+
+  /** Create a CapResult carrying a CBOR sequence (list output). */
+  static list(cborSequence) {
+    const bytes = cborSequence instanceof Uint8Array ? cborSequence : new Uint8Array(cborSequence || []);
+    return new CapResult(CapResult.KIND_LIST, bytes);
+  }
+
+  /** Create a CapResult for void caps. */
+  static empty() {
+    return new CapResult(CapResult.KIND_EMPTY, null);
+  }
+
+  /** Returns true if this is a scalar result. */
+  isScalar() { return this.kind === CapResult.KIND_SCALAR; }
+
+  /** Returns true if this is a list result. */
+  isList() { return this.kind === CapResult.KIND_LIST; }
+
+  /** Returns true if this is an empty result. */
+  isEmpty() { return this.kind === CapResult.KIND_EMPTY; }
+}
+
+// ============================================================================
+
 /**
  * Unified argument type - arguments are identified by media_urn.
  * The cap definition's sources specify how to extract values (stdin, position, cli_flag).
@@ -3189,7 +3320,7 @@ class CompositeCapSet {
    * Execute a capability by finding the best match and delegating
    * @param {string} capUrn - The capability URN to execute
    * @param {CapArgumentValue[]} args - Arguments identified by media_urn
-   * @returns {Promise<{binaryOutput: Uint8Array|null, textOutput: string|null}>}
+   * @returns {Promise<CapResult>}
    */
   async executeCap(capUrn, args) {
     let request;
@@ -5435,18 +5566,20 @@ module.exports = {
   MEDIA_NUMBER,
   MEDIA_BOOLEAN,
   MEDIA_OBJECT,
-  MEDIA_STRING_ARRAY,
-  MEDIA_INTEGER_ARRAY,
-  MEDIA_NUMBER_ARRAY,
-  MEDIA_BOOLEAN_ARRAY,
-  MEDIA_OBJECT_ARRAY,
+  // List types
+  MEDIA_LIST,
+  MEDIA_TEXTABLE_LIST,
+  MEDIA_STRING_LIST,
+  MEDIA_INTEGER_LIST,
+  MEDIA_NUMBER_LIST,
+  MEDIA_BOOLEAN_LIST,
+  MEDIA_OBJECT_LIST,
   MEDIA_IDENTITY,
   MEDIA_VOID,
   MEDIA_PNG,
   MEDIA_AUDIO,
   MEDIA_VIDEO,
   MEDIA_AUDIO_SPEECH,
-  MEDIA_IMAGE_THUMBNAIL,
   // Document types (PRIMARY naming)
   MEDIA_PDF,
   MEDIA_EPUB,
@@ -5460,11 +5593,22 @@ module.exports = {
   MEDIA_JSON,
   MEDIA_JSON_SCHEMA,
   MEDIA_YAML,
+  // Format-specific variants
+  MEDIA_JSON_VALUE,
+  MEDIA_JSON_RECORD,
+  MEDIA_JSON_LIST,
+  MEDIA_JSON_LIST_RECORD,
+  MEDIA_YAML_VALUE,
+  MEDIA_YAML_RECORD,
+  MEDIA_YAML_LIST,
+  MEDIA_YAML_LIST_RECORD,
+  MEDIA_CSV,
+  MEDIA_CSV_LIST,
   MEDIA_MODEL_SPEC,
   MEDIA_MODEL_REPO,
   MEDIA_MODEL_DIM,
   MEDIA_DECISION,
-  MEDIA_DECISION_ARRAY,
+  MEDIA_TEXTABLE_PAGE,
   // Semantic output types - model management
   MEDIA_DOWNLOAD_OUTPUT,
   MEDIA_LIST_OUTPUT,
@@ -5475,21 +5619,24 @@ module.exports = {
   // Semantic output types - inference
   MEDIA_EMBEDDING_VECTOR,
   MEDIA_LLM_INFERENCE_OUTPUT,
-  MEDIA_FILE_METADATA,
-  MEDIA_DOCUMENT_OUTLINE,
-  MEDIA_DISBOUND_PAGE,
   MEDIA_IMAGE_DESCRIPTION,
   MEDIA_TRANSCRIPTION_OUTPUT,
   // File path types
   MEDIA_FILE_PATH,
   MEDIA_FILE_PATH_ARRAY,
-  // Semantic text input types
-  MEDIA_FRONTMATTER_TEXT,
   MEDIA_MLX_MODEL_PATH,
+  // Collection types
+  MEDIA_COLLECTION,
+  MEDIA_COLLECTION_LIST,
+  // Cap execution result
+  CapResult,
   // Unified argument type
   CapArgumentValue,
   // Standard cap URN builders
-  llmConversationUrn,
+  llmGenerateTextUrn,
+  renderPageImageUrn,
+  formatConversionUrn,
+  mediaUrnForType,
   modelAvailabilityUrn,
   modelPathUrn,
   CapMatrixError,

package/capdag.test.js

@@ -13,12 +13,12 @@ const {
   StdinSource, StdinSourceKind,
   validateNoMediaSpecRedefinitionSync,
   CapArgumentValue,
-  llmConversationUrn, modelAvailabilityUrn, modelPathUrn,
+  llmGenerateTextUrn, modelAvailabilityUrn, modelPathUrn,
   MachineSyntaxError, MachineSyntaxErrorCodes, MachineEdge, Machine, MachineBuilder, parseMachine, parseMachineWithAST,
   CapRegistryEntry, MediaRegistryEntry, CapRegistryClient,
   MEDIA_STRING, MEDIA_INTEGER, MEDIA_NUMBER, MEDIA_BOOLEAN,
-  MEDIA_OBJECT, MEDIA_STRING_ARRAY, MEDIA_INTEGER_ARRAY,
-  MEDIA_NUMBER_ARRAY, MEDIA_BOOLEAN_ARRAY, MEDIA_OBJECT_ARRAY,
+  MEDIA_OBJECT, MEDIA_STRING_LIST, MEDIA_INTEGER_LIST,
+  MEDIA_NUMBER_LIST, MEDIA_BOOLEAN_LIST, MEDIA_OBJECT_LIST,
   MEDIA_IDENTITY, MEDIA_VOID, MEDIA_PNG, MEDIA_AUDIO, MEDIA_VIDEO,
   MEDIA_PDF, MEDIA_EPUB, MEDIA_MD, MEDIA_TXT, MEDIA_RST, MEDIA_LOG,
   MEDIA_HTML, MEDIA_XML, MEDIA_JSON, MEDIA_YAML, MEDIA_JSON_SCHEMA,
@@ -26,8 +26,8 @@ const {
   MEDIA_LLM_INFERENCE_OUTPUT,
   MEDIA_FILE_PATH, MEDIA_FILE_PATH_ARRAY,
   MEDIA_COLLECTION, MEDIA_COLLECTION_LIST,
-  MEDIA_DECISION, MEDIA_DECISION_ARRAY,
-  MEDIA_AUDIO_SPEECH, MEDIA_IMAGE_THUMBNAIL
+  MEDIA_DECISION,
+  MEDIA_AUDIO_SPEECH
 } = require('./capdag.js');
 
 // ============================================================================
@@ -827,7 +827,7 @@ function test061_isBinary() {
   assert(!MediaUrn.fromString(MEDIA_MD).isBinary(), 'MEDIA_MD should not be binary');
 }
 
-// TEST062: isMap true for MEDIA_OBJECT (record); false for MEDIA_STRING (form=scalar), MEDIA_STRING_ARRAY (list)
+// TEST062: isMap true for MEDIA_OBJECT (record); false for MEDIA_STRING (form=scalar), MEDIA_STRING_LIST (list)
 // TEST062: is_record returns true if record marker tag is present (key-value structure)
 function test062_isRecord() {
   assert(MediaUrn.fromString(MEDIA_OBJECT).isRecord(), 'MEDIA_OBJECT should be record');
@@ -836,7 +836,7 @@ function test062_isRecord() {
   // Without record marker, is_record is false
   assert(!MediaUrn.fromString('media:textable').isRecord(), 'plain textable should not be record');
   assert(!MediaUrn.fromString(MEDIA_STRING).isRecord(), 'MEDIA_STRING should not be record');
-  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isRecord(), 'MEDIA_STRING_ARRAY should not be record');
+  assert(!MediaUrn.fromString(MEDIA_STRING_LIST).isRecord(), 'MEDIA_STRING_LIST should not be record');
 }
 
 // TEST063: is_scalar returns true if NO list marker (scalar is default cardinality)
@@ -848,16 +848,16 @@ function test063_isScalar() {
   assert(MediaUrn.fromString(MEDIA_OBJECT).isScalar(), 'MEDIA_OBJECT (record but scalar) should be scalar');
   assert(MediaUrn.fromString('media:textable').isScalar(), 'plain textable should be scalar');
   // With list marker, is_scalar is false
-  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isScalar(), 'MEDIA_STRING_ARRAY should not be scalar');
-  assert(!MediaUrn.fromString(MEDIA_OBJECT_ARRAY).isScalar(), 'MEDIA_OBJECT_ARRAY should not be scalar');
+  assert(!MediaUrn.fromString(MEDIA_STRING_LIST).isScalar(), 'MEDIA_STRING_LIST should not be scalar');
+  assert(!MediaUrn.fromString(MEDIA_OBJECT_LIST).isScalar(), 'MEDIA_OBJECT_LIST should not be scalar');
 }
 
-// TEST064: isList true for MEDIA_STRING_ARRAY, MEDIA_INTEGER_ARRAY, MEDIA_OBJECT_ARRAY;
+// TEST064: isList true for MEDIA_STRING_LIST, MEDIA_INTEGER_LIST, MEDIA_OBJECT_LIST;
 //          false for MEDIA_STRING, MEDIA_OBJECT
 function test064_isList() {
-  assert(MediaUrn.fromString(MEDIA_STRING_ARRAY).isList(), 'MEDIA_STRING_ARRAY should be list');
-  assert(MediaUrn.fromString(MEDIA_INTEGER_ARRAY).isList(), 'MEDIA_INTEGER_ARRAY should be list');
-  assert(MediaUrn.fromString(MEDIA_OBJECT_ARRAY).isList(), 'MEDIA_OBJECT_ARRAY should be list');
+  assert(MediaUrn.fromString(MEDIA_STRING_LIST).isList(), 'MEDIA_STRING_LIST should be list');
+  assert(MediaUrn.fromString(MEDIA_INTEGER_LIST).isList(), 'MEDIA_INTEGER_LIST should be list');
+  assert(MediaUrn.fromString(MEDIA_OBJECT_LIST).isList(), 'MEDIA_OBJECT_LIST should be list');
   assert(!MediaUrn.fromString(MEDIA_STRING).isList(), 'MEDIA_STRING should not be list');
   assert(!MediaUrn.fromString(MEDIA_OBJECT).isList(), 'MEDIA_OBJECT should not be list');
 }
@@ -865,7 +865,7 @@ function test064_isList() {
 // TEST065: is_opaque returns true if NO record marker (opaque is default structure)
 function test065_isOpaque() {
   assert(MediaUrn.fromString(MEDIA_STRING).isOpaque(), 'MEDIA_STRING should be opaque');
-  assert(MediaUrn.fromString(MEDIA_STRING_ARRAY).isOpaque(), 'MEDIA_STRING_ARRAY (list but no record) should be opaque');
+  assert(MediaUrn.fromString(MEDIA_STRING_LIST).isOpaque(), 'MEDIA_STRING_LIST (list but no record) should be opaque');
   assert(MediaUrn.fromString(MEDIA_PDF).isOpaque(), 'MEDIA_PDF should be opaque');
   assert(MediaUrn.fromString('media:textable').isOpaque(), 'plain textable should be opaque');
   // With record marker, is_opaque is false
@@ -912,8 +912,8 @@ function test071_toStringRoundtrip() {
 function test072_constantsParse() {
   const constants = [
     MEDIA_STRING, MEDIA_INTEGER, MEDIA_NUMBER, MEDIA_BOOLEAN,
-    MEDIA_OBJECT, MEDIA_STRING_ARRAY, MEDIA_INTEGER_ARRAY,
-    MEDIA_NUMBER_ARRAY, MEDIA_BOOLEAN_ARRAY, MEDIA_OBJECT_ARRAY,
+    MEDIA_OBJECT, MEDIA_STRING_LIST, MEDIA_INTEGER_LIST,
+    MEDIA_NUMBER_LIST, MEDIA_BOOLEAN_LIST, MEDIA_OBJECT_LIST,
     MEDIA_IDENTITY, MEDIA_VOID, MEDIA_PNG, MEDIA_PDF, MEDIA_EPUB,
     MEDIA_MD, MEDIA_TXT, MEDIA_RST, MEDIA_LOG, MEDIA_HTML, MEDIA_XML,
     MEDIA_JSON, MEDIA_YAML, MEDIA_JSON_SCHEMA, MEDIA_AUDIO, MEDIA_VIDEO,
@@ -1052,8 +1052,8 @@ function test101_resolvedIsScalar() {
 
 // TEST102: MediaSpec with list -> isList() true
 function test102_resolvedIsList() {
-  const spec = new MediaSpec('text/plain', null, null, 'String Array', null, MEDIA_STRING_ARRAY);
-  assert(spec.isList(), 'Resolved string_array spec should be list');
+  const spec = new MediaSpec('text/plain', null, null, 'String List', null, MEDIA_STRING_LIST);
+  assert(spec.isList(), 'Resolved string_list spec should be list');
 }
 
 // TEST103: MediaSpec with json tag -> isJSON() true
@@ -1706,37 +1706,37 @@ function test309_modelAvailabilityAndPathAreDistinct() {
   assert(avail.toString() !== path.toString(), 'availability and path must be distinct');
 }
 
-// TEST310: llm_conversation_urn uses unconstrained tag (not constrained)
-function test310_llmConversationUrnUnconstrained() {
-  const urn = llmConversationUrn('en');
-  assert(urn.getTag('unconstrained') !== undefined, 'Must have unconstrained tag');
-  assert(urn.hasTag('op', 'conversation'), 'Must have op=conversation');
-  assert(urn.hasTag('language', 'en'), 'Must have language=en');
+// TEST310: llm_generate_text_urn has correct op and ml-model tags
+function test310_llmGenerateTextUrn() {
+  const urn = llmGenerateTextUrn();
+  assert(urn.hasTag('op', 'generate_text'), 'Must have op=generate_text');
+  assert(urn.getTag('llm') !== undefined, 'Must have llm tag');
+  assert(urn.getTag('ml-model') !== undefined, 'Must have ml-model tag');
 }
 
-// TEST311: llm_conversation_urn in/out specs match the expected media URNs semantically
-function test311_llmConversationUrnSpecs() {
-  const urn = llmConversationUrn('fr');
+// TEST311: llm_generate_text_urn in/out specs match MEDIA_STRING
+function test311_llmGenerateTextUrnSpecs() {
+  const urn = llmGenerateTextUrn();
   const inSpec = TaggedUrn.fromString(urn.getInSpec());
   const expectedIn = TaggedUrn.fromString(MEDIA_STRING);
   assert(inSpec.conformsTo(expectedIn), 'in_spec must conform to MEDIA_STRING');
   const outSpec = TaggedUrn.fromString(urn.getOutSpec());
-  const expectedOut = TaggedUrn.fromString(MEDIA_LLM_INFERENCE_OUTPUT);
-  assert(outSpec.conformsTo(expectedOut), 'out_spec must conform to MEDIA_LLM_INFERENCE_OUTPUT');
+  const expectedOut = TaggedUrn.fromString(MEDIA_STRING);
+  assert(outSpec.conformsTo(expectedOut), 'out_spec must conform to MEDIA_STRING');
 }
 
 // TEST312: All URN builders produce parseable cap URNs
 function test312_allUrnBuildersProduceValidUrns() {
   const avail = modelAvailabilityUrn();
   const path = modelPathUrn();
-  const conv = llmConversationUrn('en');
+  const llmGen = llmGenerateTextUrn();
 
   const parsedAvail = CapUrn.fromString(avail.toString());
   assert(parsedAvail !== null, 'modelAvailabilityUrn must be parseable');
   const parsedPath = CapUrn.fromString(path.toString());
   assert(parsedPath !== null, 'modelPathUrn must be parseable');
-  const parsedConv = CapUrn.fromString(conv.toString());
-  assert(parsedConv !== null, 'llmConversationUrn must be parseable');
+  const parsedLlmGen = CapUrn.fromString(llmGen.toString());
+  assert(parsedLlmGen !== null, 'llmGenerateTextUrn must be parseable');
 }
 
 // ============================================================================
@@ -2398,7 +2398,7 @@ function test335_cartridgeRepoServerClientIntegration() {
 // TEST546: isImage returns true only when image marker tag is present
 function test546_isImage() {
   assert(MediaUrn.fromString(MEDIA_PNG).isImage(), 'MEDIA_PNG should be image');
-  assert(MediaUrn.fromString(MEDIA_IMAGE_THUMBNAIL).isImage(), 'MEDIA_IMAGE_THUMBNAIL should be image');
+  assert(MediaUrn.fromString('media:image;png;thumbnail').isImage(), 'media:image;png;thumbnail should be image');
   assert(MediaUrn.fromString('media:image;jpg').isImage(), 'media:image;jpg should be image');
   // Non-image types
   assert(!MediaUrn.fromString(MEDIA_PDF).isImage(), 'MEDIA_PDF should not be image');
@@ -2432,8 +2432,8 @@ function test548_isVideo() {
 function test549_isNumeric() {
   assert(MediaUrn.fromString(MEDIA_INTEGER).isNumeric(), 'MEDIA_INTEGER should be numeric');
   assert(MediaUrn.fromString(MEDIA_NUMBER).isNumeric(), 'MEDIA_NUMBER should be numeric');
-  assert(MediaUrn.fromString(MEDIA_INTEGER_ARRAY).isNumeric(), 'MEDIA_INTEGER_ARRAY should be numeric');
-  assert(MediaUrn.fromString(MEDIA_NUMBER_ARRAY).isNumeric(), 'MEDIA_NUMBER_ARRAY should be numeric');
+  assert(MediaUrn.fromString(MEDIA_INTEGER_LIST).isNumeric(), 'MEDIA_INTEGER_LIST should be numeric');
+  assert(MediaUrn.fromString(MEDIA_NUMBER_LIST).isNumeric(), 'MEDIA_NUMBER_LIST should be numeric');
   // Non-numeric types
   assert(!MediaUrn.fromString(MEDIA_STRING).isNumeric(), 'MEDIA_STRING should not be numeric');
   assert(!MediaUrn.fromString(MEDIA_BOOLEAN).isNumeric(), 'MEDIA_BOOLEAN should not be numeric');
@@ -2443,9 +2443,9 @@ function test549_isNumeric() {
 // TEST550: isBool returns true only when bool marker tag is present
 function test550_isBool() {
   assert(MediaUrn.fromString(MEDIA_BOOLEAN).isBool(), 'MEDIA_BOOLEAN should be bool');
-  assert(MediaUrn.fromString(MEDIA_BOOLEAN_ARRAY).isBool(), 'MEDIA_BOOLEAN_ARRAY should be bool');
-  assert(MediaUrn.fromString(MEDIA_DECISION).isBool(), 'MEDIA_DECISION should be bool');
-  assert(MediaUrn.fromString(MEDIA_DECISION_ARRAY).isBool(), 'MEDIA_DECISION_ARRAY should be bool');
+  assert(MediaUrn.fromString(MEDIA_BOOLEAN_LIST).isBool(), 'MEDIA_BOOLEAN_LIST should be bool');
+  // MEDIA_DECISION is now a JSON record type (not bool)
+  assert(!MediaUrn.fromString(MEDIA_DECISION).isBool(), 'MEDIA_DECISION should not be bool (it is a JSON record now)');
   // Non-bool types
   assert(!MediaUrn.fromString(MEDIA_STRING).isBool(), 'MEDIA_STRING should not be bool');
   assert(!MediaUrn.fromString(MEDIA_INTEGER).isBool(), 'MEDIA_INTEGER should not be bool');
@@ -2468,7 +2468,7 @@ function test552_isFilePathArray() {
   // Scalar file-path is NOT isFilePathArray
   assert(!MediaUrn.fromString(MEDIA_FILE_PATH).isFilePathArray(), 'MEDIA_FILE_PATH should not be isFilePathArray');
   // Non-file-path types
-  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isFilePathArray(), 'MEDIA_STRING_ARRAY should not be file-path-array');
+  assert(!MediaUrn.fromString(MEDIA_STRING_LIST).isFilePathArray(), 'MEDIA_STRING_LIST should not be file-path-array');
 }
 
 // TEST553: isAnyFilePath returns true for both scalar and array file-path
@@ -2477,7 +2477,7 @@ function test553_isAnyFilePath() {
   assert(MediaUrn.fromString(MEDIA_FILE_PATH_ARRAY).isAnyFilePath(), 'MEDIA_FILE_PATH_ARRAY should be any-file-path');
   // Non-file-path types
   assert(!MediaUrn.fromString(MEDIA_STRING).isAnyFilePath(), 'MEDIA_STRING should not be any-file-path');
-  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isAnyFilePath(), 'MEDIA_STRING_ARRAY should not be any-file-path');
+  assert(!MediaUrn.fromString(MEDIA_STRING_LIST).isAnyFilePath(), 'MEDIA_STRING_LIST should not be any-file-path');
 }
 
 // TEST554: isCollection returns true when collection marker tag is present
@@ -5408,8 +5408,8 @@ async function runTests() {
   runTest('TEST307: model_availability_urn', test307_modelAvailabilityUrn);
   runTest('TEST308: model_path_urn', test308_modelPathUrn);
   runTest('TEST309: model_availability_and_path_are_distinct', test309_modelAvailabilityAndPathAreDistinct);
-  runTest('TEST310: llm_conversation_urn_unconstrained', test310_llmConversationUrnUnconstrained);
-  runTest('TEST311: llm_conversation_urn_specs', test311_llmConversationUrnSpecs);
+  runTest('TEST310: llm_generate_text_urn', test310_llmGenerateTextUrn);
+  runTest('TEST311: llm_generate_text_urn_specs', test311_llmGenerateTextUrnSpecs);
   runTest('TEST312: all_urn_builders_produce_valid_urns', test312_allUrnBuildersProduceValidUrns);
 
   // JS-specific tests (no Rust number)

package/package.json

@@ -40,5 +40,5 @@
     "pretest": "npm run build:parser",
     "test": "node capdag.test.js"
   },
-  "version": "0.126.278"
+  "version": "0.127.280"
 }