narrator-ts 0.1.1 → 0.1.2

package/README.md

@@ -87,7 +87,9 @@ Create the versioned IFF resource consumed by AROS `translator.library`,
 npm run export:aros -- -o speech.iff
 npm run export:aros -- -o speech.iff \
   --translator data/translator-33.2.json \
-  --voice data/narrator-33.2.json
+  --voice data/narrator-33.2.json \
+  --translator-license "User supplied; redistribution not granted" \
+  --voice-license "User supplied; redistribution not granted"
 npm run export:aros -- -o speech-resource.c --format c
 ```
 
@@ -96,6 +98,14 @@ locally extracted authentic tables; the resulting file has the same legal
 status as those inputs and should not be redistributed.
 The C form contains the identical IFF payload as a byte array for ROM builds.
 
+`FORM NARR` uses ordinary length-delimited Latin-1 IFF chunks rather than an
+embedded serialization format. `VERS` is the binary resource schema version;
+`FVER` records the narrator-ts package version. `TVER`/`TSRC`/`TLIC` describe
+the translator and `VVER`/`VSRC`/`VLIC` describe the voice, followed by their
+`LTRS` and `NVOI` table chunks. The built-in free inputs are labelled public
+domain. Explicit table paths conservatively default to `User supplied;
+redistribution not granted`; the two `--*-license` options override that text.
+
 ## Status
 
 | | |

package/dist/aros-resource/index.d.ts

@@ -14,6 +14,21 @@ declare const ALT_VOICE_COLUMNS: readonly ["f1", "f2", "f3"];
 export interface ArosResourceInput {
     translator?: TranslatorTables;
     voice?: VoiceData;
+    metadata: {
+        generator: string;
+        translatorLicense?: string;
+        voiceLicense?: string;
+    };
+}
+export interface ArosComponentMetadata {
+    version?: string;
+    source?: string;
+    license?: string;
+}
+export interface ArosResourceMetadata {
+    generator?: string;
+    translator?: ArosComponentMetadata;
+    voice?: ArosComponentMetadata;
 }
 export interface ArosVoiceTables {
     names: string[];
@@ -26,7 +41,7 @@ export interface ArosVoiceTables {
 }
 export interface DecodedArosResource {
     version: number;
-    metadata: Record<string, unknown>;
+    metadata: ArosResourceMetadata;
     translator?: TranslatorTables;
     voice?: ArosVoiceTables;
 }

package/dist/aros-resource/index.js

@@ -49,6 +49,16 @@ class Writer {
             this.u8(code);
         }
     }
+    text(value, label) {
+        if (value.length === 0 || value.length > 0xff)
+            throw new RangeError(`${label} must be 1..255 bytes`);
+        for (const c of value) {
+            const code = c.charCodeAt(0);
+            if (code === 0 || code > 0xff)
+                throw new RangeError(`${label} is not non-NUL Latin-1 text`);
+            this.u8(code);
+        }
+    }
     finish() { return Uint8Array.from(this.bytes); }
 }
 class Reader {
@@ -98,6 +108,11 @@ function chunk(id, payload) {
         w.u8(0);
     return w.finish();
 }
+function textChunk(id, value) {
+    const w = new Writer();
+    w.text(value, id);
+    return chunk(id, w.finish());
+}
 function translatorChunk(data) {
     if (data.classes.length !== 128 || data.buckets.length !== 28)
         throw new RangeError('invalid translator table shape');
@@ -167,18 +182,27 @@ function voiceChunk(data) {
 export function encodeArosResource(input) {
     if (!input.translator && !input.voice)
         throw new RangeError('resource contains no tables');
+    if (!input.metadata?.generator)
+        throw new RangeError('resource generator is required');
+    if (input.translator && !input.metadata.translatorLicense)
+        throw new RangeError('translator license is required');
+    if (input.voice && !input.metadata.voiceLicense)
+        throw new RangeError('voice license is required');
     const version = new Writer();
     version.u32(AROS_RESOURCE_VERSION);
-    const meta = new TextEncoder().encode(JSON.stringify({
-        format: 'AROS Narrator Resource',
-        translator: input.translator && { version: input.translator.version, source: input.translator.source },
-        voice: input.voice && { version: input.voice.version, source: input.voice.source },
-    }));
-    const chunks = [chunk('VERS', version.finish()), chunk('META', meta)];
-    if (input.translator)
+    const chunks = [chunk('VERS', version.finish()), textChunk('FVER', input.metadata.generator)];
+    if (input.translator) {
+        chunks.push(textChunk('TVER', input.translator.version));
+        chunks.push(textChunk('TSRC', input.translator.source));
+        chunks.push(textChunk('TLIC', input.metadata.translatorLicense));
         chunks.push(chunk('LTRS', translatorChunk(input.translator)));
-    if (input.voice)
+    }
+    if (input.voice) {
+        chunks.push(textChunk('VVER', input.voice.version));
+        chunks.push(textChunk('VSRC', input.voice.source));
+        chunks.push(textChunk('VLIC', input.metadata.voiceLicense));
         chunks.push(chunk('NVOI', voiceChunk(input.voice)));
+    }
     const body = concat(chunks);
     const head = new Writer();
     head.id('FORM');
@@ -215,18 +239,31 @@ function chunksFrom(bytes) {
     if (ascii(0) !== 'FORM' || ascii(8) !== AROS_RESOURCE_FORM || u32(4) + 8 !== bytes.length)
         throw new RangeError('not an AROS Narrator IFF resource');
     const chunks = new Map();
-    for (let at = 12; at < bytes.length;) {
+    const singletons = new Set(['VERS', 'FVER', 'TVER', 'TSRC', 'TLIC', 'LTRS', 'VVER', 'VSRC', 'VLIC', 'NVOI']);
+    let at = 12;
+    while (at < bytes.length) {
         if (at + 8 > bytes.length)
             throw new RangeError('truncated IFF chunk');
         const id = ascii(at), size = u32(at + 4), start = at + 8, end = start + size;
         if (end > bytes.length)
             throw new RangeError('truncated IFF chunk payload');
+        if (singletons.has(id) && chunks.has(id))
+            throw new RangeError(`duplicate ${id} chunk`);
         chunks.set(id, bytes.subarray(start, end));
         at = end + (size & 1);
     }
+    if (at !== bytes.length)
+        throw new RangeError('missing IFF pad byte');
     return chunks;
 }
-function decodeTranslator(bytes) {
+function decodeText(bytes, id) {
+    if (!bytes)
+        return undefined;
+    if (bytes.length === 0 || bytes.length > 0xff || bytes.includes(0))
+        throw new RangeError(`invalid ${id} text chunk`);
+    return String.fromCharCode(...bytes);
+}
+function decodeTranslator(bytes, metadata) {
     const r = new Reader(bytes);
     const classes = Array.from({ length: r.u16() }, () => r.u16());
     const wildcards = r.latin8();
@@ -242,7 +279,11 @@ function decodeTranslator(bytes) {
     }
     if (!r.done())
         throw new RangeError('trailing translator data');
-    return { version: 'resource', source: 'IFF LTRS', classes, wildcards, vowels, buckets };
+    return {
+        version: metadata?.version ?? 'resource',
+        source: metadata?.source ?? 'IFF LTRS',
+        classes, wildcards, vowels, buckets,
+    };
 }
 function decodeVoice(bytes) {
     const r = new Reader(bytes), count = r.u16();
@@ -275,8 +316,25 @@ export function decodeArosResource(bytes) {
     const version = new DataView(versionBytes.buffer, versionBytes.byteOffset, 4).getUint32(0);
     if (version !== AROS_RESOURCE_VERSION)
         throw new RangeError(`unsupported resource version ${version}`);
-    const metadata = JSON.parse(new TextDecoder().decode(chunks.get('META') ?? new Uint8Array()));
-    const translator = chunks.has('LTRS') ? decodeTranslator(chunks.get('LTRS')) : undefined;
+    const translatorMetadata = {
+        version: decodeText(chunks.get('TVER'), 'TVER'),
+        source: decodeText(chunks.get('TSRC'), 'TSRC'),
+        license: decodeText(chunks.get('TLIC'), 'TLIC'),
+    };
+    const voiceMetadata = {
+        version: decodeText(chunks.get('VVER'), 'VVER'),
+        source: decodeText(chunks.get('VSRC'), 'VSRC'),
+        license: decodeText(chunks.get('VLIC'), 'VLIC'),
+    };
+    const metadata = {};
+    const generator = decodeText(chunks.get('FVER'), 'FVER');
+    if (generator !== undefined)
+        metadata.generator = generator;
+    if (Object.values(translatorMetadata).some((value) => value !== undefined))
+        metadata.translator = translatorMetadata;
+    if (Object.values(voiceMetadata).some((value) => value !== undefined))
+        metadata.voice = voiceMetadata;
+    const translator = chunks.has('LTRS') ? decodeTranslator(chunks.get('LTRS'), metadata.translator) : undefined;
     const voice = chunks.has('NVOI') ? decodeVoice(chunks.get('NVOI')) : undefined;
     return { version, metadata, translator, voice };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "narrator-ts",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript reimplementation of the Amiga narrator.device and translator.library",
   "type": "module",
   "license": "MIT",