@carbonenginejs/runtime-resource 0.20.0 → 0.22.0

package/dist/formats/fsd/64/core/CjsFsd64SchemaDecoder.js

@@ -0,0 +1,389 @@
+import { AssertFlags, ReadRequiredString } from './fsd64Records.js';
+import { CjsFsd64Binary } from './CjsFsd64Binary.js';
+
+const SCHEMA_NAME = "carbonenginejs.fsdBinarySchema";
+const SCHEMA_VERSION = 1;
+const TYPE_SIZES = {
+  [CjsFsd64Binary.Type.BOOLEAN]: 1,
+  [CjsFsd64Binary.Type.FLOAT_32]: 4,
+  [CjsFsd64Binary.Type.FLOAT_64]: 8,
+  [CjsFsd64Binary.Type.INT_32]: 4,
+  [CjsFsd64Binary.Type.INT_32_IDENTIFIER]: 4,
+  [CjsFsd64Binary.Type.LIST]: 8,
+  [CjsFsd64Binary.Type.MAP]: 16,
+  [CjsFsd64Binary.Type.STRING]: 8,
+  [CjsFsd64Binary.Type.UINT_8]: 1,
+  [CjsFsd64Binary.Type.UINT_32]: 4,
+  [CjsFsd64Binary.Type.UINT_32_IDENTIFIER]: 4,
+  [CjsFsd64Binary.Type.UINT_64]: 8,
+  [CjsFsd64Binary.Type.UINT_64_IDENTIFIER]: 8
+};
+
+/**
+ * Validates declarative binary schemas and decodes caller-supplied bytes.
+ */
+class CjsFsd64SchemaDecoder {
+  /**
+   * Validates and returns one inert JSON schema definition.
+   */
+  static defineSchema(schema) {
+    ValidateSchema(schema);
+    return schema;
+  }
+
+  /**
+   * Decodes a schema-defined value using the established private reader
+   * contract: Maps and numeric identifier values.
+   */
+  static read(bytes, schema) {
+    return DecodeRoot(bytes, schema, false);
+  }
+
+  /**
+   * Decodes a schema-defined value to plain JSON-compatible objects.
+   * Identifier keys and values are emitted as lossless decimal strings.
+   */
+  static readJSON(bytes, schema) {
+    return DecodeRoot(bytes, schema, true);
+  }
+}
+function DecodeRoot(bytes, schema, json) {
+  ValidateSchema(schema);
+  const binary = new CjsFsd64Binary(bytes, {
+    path: schema.path,
+    schemaID: [schema.schemaID, ...(schema.acceptedSchemaIDs ?? [])]
+  });
+  const containerOffset = binary.RootOffset + (schema.container.offset ?? 0);
+
+  // A root OBJECT is how a dataset that publishes several independent maps is
+  // described, such as audio metadata's events, sound banks and WEM files.
+  return ResolveFsdType(schema.container.type) === CjsFsd64Binary.Type.OBJECT ? DecodeObject(binary, containerOffset, schema.container, json, schema.path) : DecodeMap(binary, containerOffset, schema.container, json, schema.path);
+}
+function DecodeValue(binary, baseOffset, descriptor, json, path, field) {
+  const type = ResolveFsdType(descriptor.type);
+  const offset = baseOffset + (descriptor.offset ?? 0);
+  switch (type) {
+    case CjsFsd64Binary.Type.BOOLEAN:
+      return (binary.Byte(offset) & 1 << (descriptor.bit ?? 0)) !== 0;
+    case CjsFsd64Binary.Type.FLOAT_32:
+      return binary.Float32(offset);
+    case CjsFsd64Binary.Type.FLOAT_64:
+      return binary.Float64(offset);
+    case CjsFsd64Binary.Type.INT_32:
+      return binary.Int32(offset);
+    case CjsFsd64Binary.Type.INT_32_IDENTIFIER:
+      return FormatIdentifier(binary.Int32(offset), json);
+    case CjsFsd64Binary.Type.LIST:
+      return DecodeList(binary, offset, descriptor, json, path, field);
+    case CjsFsd64Binary.Type.MAP:
+      return DecodeMap(binary, offset, descriptor, json, path);
+    case CjsFsd64Binary.Type.OBJECT:
+      return DecodeObject(binary, offset, descriptor, json, path);
+    case CjsFsd64Binary.Type.STRING:
+      return ReadRequiredString(binary, offset, path, field);
+    case CjsFsd64Binary.Type.UINT_8:
+      return binary.Byte(offset);
+    case CjsFsd64Binary.Type.UINT_32:
+      return binary.Uint32(offset);
+    case CjsFsd64Binary.Type.UINT_32_IDENTIFIER:
+      return FormatIdentifier(binary.Uint32(offset), json);
+    case CjsFsd64Binary.Type.UINT_64:
+      return binary.Uint64(offset);
+    case CjsFsd64Binary.Type.UINT_64_IDENTIFIER:
+      return json ? binary.Uint64Identity(offset) : binary.Uint64(offset);
+    default:
+      throw SchemaError(`Unsupported FSD binary type: ${descriptor.type}`);
+  }
+}
+function DecodeObject(binary, baseOffset, descriptor, json, path) {
+  const flags = descriptor.presence ? DecodeValue(binary, baseOffset, descriptor.presence, false, path, "<presence>") : 0;
+  if (descriptor.presence) {
+    AssertFlags(flags, descriptor.presence.allowedMask, path);
+  }
+  const value = {};
+  for (const field of descriptor.fields) {
+    if (field.presenceMask !== undefined && (flags & field.presenceMask) === 0) {
+      continue;
+    }
+    DefineValue(value, field.name, DecodeValue(binary, baseOffset, field, json, path, field.name));
+  }
+  return value;
+}
+function DecodeList(binary, pointerOffset, descriptor, json, path, field) {
+  const relativeOffset = binary.Uint64(pointerOffset);
+  const offsets = binary.ListEntries(relativeOffset, descriptor.itemSize, descriptor.maximumCount ?? Number.MAX_SAFE_INTEGER);
+  return offsets.map(offset => DecodeValue(binary, offset, descriptor.item, json, path, `${field}[]`));
+}
+function DecodeMap(binary, headerOffset, descriptor, json, path) {
+  const entries = [];
+  for (const recordOffset of binary.MapEntries(descriptor.recordSize, headerOffset)) {
+    const key = DecodeValue(binary, recordOffset, descriptor.key, json, path, "<key>");
+    const value = descriptor.value ? DecodeValue(binary, recordOffset, descriptor.value, json, path, "<value>") : DecodeObject(binary, recordOffset + (descriptor.recordOffset ?? 0), descriptor, json, path);
+    entries.push([key, value]);
+  }
+  return json ? CreateJSONObject(entries, path, descriptor.key.type) : CreateMap(entries, path);
+}
+function FormatIdentifier(value, json) {
+  return json ? value.toString(10) : value;
+}
+function CreateMap(entries, path) {
+  const result = new Map();
+  for (const [key, value] of entries) {
+    if (result.has(key)) {
+      throw DuplicateKeyError(key, path);
+    }
+    result.set(key, value);
+  }
+  return result;
+}
+function CreateJSONObject(entries, path, keyType) {
+  entries.sort(([left], [right]) => CompareKeys(left, right, keyType));
+  const result = {};
+  for (const [key, value] of entries) {
+    const property = String(key);
+    if (Object.hasOwn(result, property)) {
+      throw DuplicateKeyError(property, path);
+    }
+    DefineValue(result, property, value);
+  }
+  return result;
+}
+function CompareKeys(left, right, type) {
+  if (IsIntegerType(type)) {
+    const leftValue = BigInt(left);
+    const rightValue = BigInt(right);
+    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+  }
+  const leftValue = String(left);
+  const rightValue = String(right);
+  return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
+function IsIntegerType(type) {
+  return type === CjsFsd64Binary.Type.INT_32 || type === CjsFsd64Binary.Type.INT_32_IDENTIFIER || type === CjsFsd64Binary.Type.UINT_8 || type === CjsFsd64Binary.Type.UINT_32 || type === CjsFsd64Binary.Type.UINT_32_IDENTIFIER || type === CjsFsd64Binary.Type.UINT_64 || type === CjsFsd64Binary.Type.UINT_64_IDENTIFIER;
+}
+function DefineValue(target, property, value) {
+  Object.defineProperty(target, property, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+function DuplicateKeyError(key, path) {
+  const error = new Error(`Duplicate FSD map key in ${path}: ${key}`);
+  error.code = "CJS_FSD_DUPLICATE_KEY";
+  error.key = key;
+  error.path = path;
+  return error;
+}
+function ValidateSchema(schema) {
+  if (!IsPlainObject(schema) || schema.schema !== SCHEMA_NAME || schema.schemaVersion !== SCHEMA_VERSION) {
+    throw SchemaError(`FSD binary schema must be ${SCHEMA_NAME} version ${SCHEMA_VERSION}.`);
+  }
+  if (typeof schema.path !== "string" || schema.path.trim() === "") {
+    throw SchemaError("FSD binary schema path must be a non-empty string.");
+  }
+  if (typeof schema.name !== "string" || schema.name.trim() === "") {
+    throw SchemaError("FSD binary schema name must be a non-empty string.");
+  }
+
+  // 32 characters pin the layout alone, which survives a content change and
+  // another publisher's build; 48 additionally pin one build's content digest.
+  if (typeof schema.schemaID !== "string" || !/^(?:[0-9a-f]{32}|[0-9a-f]{48})$/iu.test(schema.schemaID)) {
+    throw SchemaError("FSD binary schema identity must contain 32 or 48 hexadecimal characters.");
+  }
+
+  // A schema identity is not a hash of the byte layout alone, so one layout
+  // can carry two of them across publishers. Additional identities are
+  // accepted only where the layout was measured to be the same.
+  if (schema.acceptedSchemaIDs !== undefined) {
+    if (!Array.isArray(schema.acceptedSchemaIDs) || schema.acceptedSchemaIDs.some(value => typeof value !== "string" || !/^(?:[0-9a-f]{32}|[0-9a-f]{48})$/iu.test(value))) {
+      throw SchemaError("FSD binary accepted schema identities must be 32 or 48 hexadecimal characters each.");
+    }
+  }
+  if (!IsPlainObject(schema.container)) {
+    throw SchemaError("FSD binary schema root must be a MAP or an OBJECT.");
+  }
+  const rootType = ResolveFsdType(schema.container.type);
+  if (rootType !== CjsFsd64Binary.Type.MAP && rootType !== CjsFsd64Binary.Type.OBJECT) {
+    throw SchemaError("FSD binary schema root must be a MAP or an OBJECT.");
+  }
+  AssertOffset(schema.container.offset ?? 0, "container.offset");
+  if (rootType === CjsFsd64Binary.Type.OBJECT) {
+    AssertPositiveInteger(schema.container.headerSize, "container.headerSize");
+    ValidateObjectDescriptor(schema.container, schema.container.headerSize, "container");
+    return;
+  }
+  ValidateMapDescriptor(schema.container, "container");
+}
+function ValidateMapDescriptor(descriptor, label) {
+  AssertPositiveInteger(descriptor.recordSize, `${label}.recordSize`);
+  ValidateValueDescriptor(descriptor.key, descriptor.recordSize, `${label}.key`);
+  if (descriptor.value !== undefined) {
+    if (descriptor.fields !== undefined || descriptor.presence !== undefined || descriptor.recordOffset !== undefined) {
+      throw SchemaError(`${label} cannot combine value with object record metadata.`);
+    }
+    ValidateValueDescriptor(descriptor.value, descriptor.recordSize, `${label}.value`);
+    return;
+  }
+  const recordOffset = descriptor.recordOffset ?? 0;
+  AssertOffset(recordOffset, `${label}.recordOffset`);
+  if (recordOffset > descriptor.recordSize) {
+    throw SchemaError(`${label}.recordOffset exceeds the record size.`);
+  }
+  ValidateObjectDescriptor(descriptor, descriptor.recordSize - recordOffset, label);
+}
+function ValidateObjectDescriptor(descriptor, availableSize, label) {
+  if (!Array.isArray(descriptor.fields)) {
+    throw SchemaError(`${label}.fields must be an array.`);
+  }
+  if (descriptor.presence !== undefined) {
+    ValidateValueDescriptor(descriptor.presence, availableSize, `${label}.presence`);
+    const presenceType = ResolveFsdType(descriptor.presence.type);
+    if (presenceType !== CjsFsd64Binary.Type.UINT_32 && presenceType !== CjsFsd64Binary.Type.UINT_64) {
+      throw SchemaError(`${label}.presence must use UINT_32 or UINT_64.`);
+    }
+    AssertSafeMask(descriptor.presence.allowedMask, `${label}.presence.allowedMask`);
+  }
+  const names = new Set();
+  let previousOffset = -1;
+  for (let index = 0; index < descriptor.fields.length; index++) {
+    const field = descriptor.fields[index];
+    const fieldLabel = `${label}.fields[${index}]`;
+    ValidateValueDescriptor(field, availableSize, fieldLabel);
+    const offset = field.offset ?? 0;
+    if (offset < previousOffset) {
+      throw SchemaError(`${label}.fields must be ordered by byte offset.`);
+    }
+    previousOffset = offset;
+    if (typeof field.name !== "string" || field.name === "") {
+      throw SchemaError(`${fieldLabel}.name must be a non-empty string.`);
+    }
+    if (names.has(field.name)) {
+      throw SchemaError(`FSD binary schema field is duplicated: ${field.name}`);
+    }
+    names.add(field.name);
+    ValidateSourceName(field, fieldLabel);
+    ValidatePresenceMask(field, descriptor.presence, fieldLabel);
+  }
+}
+
+/**
+ * Converts a client field name to the name the export publishes.
+ *
+ * The newer datasets name fields in snake_case and CCP's exporter camelCases
+ * them, with one wrinkle worth writing down rather than remembering: a trailing
+ * `id` segment becomes `ID`, so `type_id` is published as `typeID` and not
+ * `typeId`. That rule was applied by hand across the SKINR schemas before it
+ * was written anywhere, and by hand it was applied inconsistently.
+ *
+ * @param {string} sourceName Field name as the client stores it.
+ * @returns {string} Field name as the export publishes it.
+ */
+function CamelizeFieldName(sourceName) {
+  return String(sourceName).split("_").map((segment, index) => {
+    if (segment.toLowerCase() === "id") return "ID";
+    return index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1);
+  }).join("");
+}
+
+/**
+ * Checks a field's name against the client's own name for it.
+ *
+ * A schema may record `sourceName`, the name the loader gives the field. When
+ * it does, the decoded name must be the mechanical conversion of it - which is
+ * what makes the conversion checkable rather than a transcription nobody can
+ * audit. A field that departs deliberately, such as a label identifier the
+ * export republishes as resolved text, declares `renamed: true` and says why in
+ * the reader.
+ */
+function ValidateSourceName(descriptor, label) {
+  if (descriptor.sourceName === undefined) return;
+  if (typeof descriptor.sourceName !== "string" || descriptor.sourceName === "") {
+    throw SchemaError(`${label}.sourceName must be a non-empty string.`);
+  }
+  if (descriptor.renamed === true) return;
+  const expected = CamelizeFieldName(descriptor.sourceName);
+  if (descriptor.name !== expected) {
+    throw SchemaError(`${label} is named ${descriptor.name} but its source ${descriptor.sourceName} ` + `converts to ${expected}. Set renamed: true if the departure is deliberate.`);
+  }
+}
+function ValidateValueDescriptor(descriptor, availableSize, label) {
+  if (!IsPlainObject(descriptor)) {
+    throw SchemaError(`${label} must be an object.`);
+  }
+  const type = ResolveFsdType(descriptor.type);
+  if (type === CjsFsd64Binary.Type.OBJECT) {
+    const offset = descriptor.offset ?? 0;
+    AssertOffset(offset, `${label}.offset`);
+    if (offset > availableSize) {
+      throw SchemaError(`${label}.offset exceeds its containing record.`);
+    }
+    ValidateObjectDescriptor(descriptor, availableSize - offset, label);
+    return;
+  }
+  AssertOffset(descriptor.offset, `${label}.offset`);
+  if (descriptor.offset + TYPE_SIZES[type] > availableSize) {
+    throw SchemaError(`${label} exceeds its ${availableSize}-byte record.`);
+  }
+  if (type === CjsFsd64Binary.Type.LIST) {
+    AssertPositiveInteger(descriptor.itemSize, `${label}.itemSize`);
+    if (descriptor.maximumCount !== undefined) {
+      AssertPositiveInteger(descriptor.maximumCount, `${label}.maximumCount`);
+    }
+    ValidateValueDescriptor(descriptor.item, descriptor.itemSize, `${label}.item`);
+  } else if (type === CjsFsd64Binary.Type.MAP) {
+    ValidateMapDescriptor(descriptor, label);
+  }
+}
+function ValidatePresenceMask(field, presence, label) {
+  if (field.presenceMask === undefined) {
+    return;
+  }
+  if (!presence) {
+    throw SchemaError(`${label}.presenceMask requires record presence metadata.`);
+  }
+  AssertSafeMask(field.presenceMask, `${label}.presenceMask`);
+  if (field.presenceMask === 0 || !Number.isInteger(Math.log2(field.presenceMask))) {
+    throw SchemaError(`${label}.presenceMask must contain exactly one bit.`);
+  }
+  if ((field.presenceMask & presence.allowedMask) === 0) {
+    throw SchemaError(`${label}.presenceMask is outside the allowed presence mask.`);
+  }
+}
+function ResolveFsdType(type) {
+  if (typeof type !== "string" || !Object.hasOwn(CjsFsd64Binary.Type, type)) {
+    throw SchemaError(`Unknown FSD binary type: ${String(type)}`);
+  }
+  return CjsFsd64Binary.Type[type];
+}
+function AssertOffset(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw SchemaError(`${label} must be a non-negative safe integer.`);
+  }
+}
+function AssertPositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw SchemaError(`${label} must be a positive safe integer.`);
+  }
+}
+function AssertSafeMask(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw SchemaError(`${label} must be a non-negative safe-integer mask.`);
+  }
+}
+function IsPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function SchemaError(message) {
+  const error = new TypeError(message);
+  error.code = "CJS_FSD_BINARY_SCHEMA_INVALID";
+  return error;
+}
+
+export { CamelizeFieldName, CjsFsd64SchemaDecoder };
+//# sourceMappingURL=CjsFsd64SchemaDecoder.js.map

package/dist/formats/fsd/64/core/CjsFsd64SchemaDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsFsd64SchemaDecoder.js","sources":["../../../../../../src/formats/fsd/64/core/CjsFsd64SchemaDecoder.js"],"sourcesContent":["import { AssertFlags, ReadRequiredString } from \"./fsd64Records.js\";\nimport { CjsFsd64Binary } from \"./CjsFsd64Binary.js\";\n\nconst SCHEMA_NAME = \"carbonenginejs.fsdBinarySchema\";\nconst SCHEMA_VERSION = 1;\nconst TYPE_SIZES = {\n    [CjsFsd64Binary.Type.BOOLEAN]: 1,\n    [CjsFsd64Binary.Type.FLOAT_32]: 4,\n    [CjsFsd64Binary.Type.FLOAT_64]: 8,\n    [CjsFsd64Binary.Type.INT_32]: 4,\n    [CjsFsd64Binary.Type.INT_32_IDENTIFIER]: 4,\n    [CjsFsd64Binary.Type.LIST]: 8,\n    [CjsFsd64Binary.Type.MAP]: 16,\n    [CjsFsd64Binary.Type.STRING]: 8,\n    [CjsFsd64Binary.Type.UINT_8]: 1,\n    [CjsFsd64Binary.Type.UINT_32]: 4,\n    [CjsFsd64Binary.Type.UINT_32_IDENTIFIER]: 4,\n    [CjsFsd64Binary.Type.UINT_64]: 8,\n    [CjsFsd64Binary.Type.UINT_64_IDENTIFIER]: 8,\n};\n\n/**\n * Validates declarative binary schemas and decodes caller-supplied bytes.\n */\nexport class CjsFsd64SchemaDecoder\n{\n    /**\n     * Validates and returns one inert JSON schema definition.\n     */\n    static defineSchema(schema)\n    {\n        ValidateSchema(schema);\n        return schema;\n    }\n\n    /**\n     * Decodes a schema-defined value using the established private reader\n     * contract: Maps and numeric identifier values.\n     */\n    static read(bytes, schema)\n    {\n        return DecodeRoot(bytes, schema, false);\n    }\n\n    /**\n     * Decodes a schema-defined value to plain JSON-compatible objects.\n     * Identifier keys and values are emitted as lossless decimal strings.\n     */\n    static readJSON(bytes, schema)\n    {\n        return DecodeRoot(bytes, schema, true);\n    }\n}\n\nfunction DecodeRoot(bytes, schema, json)\n{\n    ValidateSchema(schema);\n\n    const binary = new CjsFsd64Binary(bytes, {\n        path: schema.path,\n        schemaID: [ schema.schemaID, ...(schema.acceptedSchemaIDs ?? []) ],\n    });\n    const containerOffset = binary.RootOffset + (schema.container.offset ?? 0);\n\n    // A root OBJECT is how a dataset that publishes several independent maps is\n    // described, such as audio metadata's events, sound banks and WEM files.\n    return ResolveFsdType(schema.container.type) === CjsFsd64Binary.Type.OBJECT\n        ? DecodeObject(binary, containerOffset, schema.container, json, schema.path)\n        : DecodeMap(binary, containerOffset, schema.container, json, schema.path);\n}\n\nfunction DecodeValue(binary, baseOffset, descriptor, json, path, field)\n{\n    const type = ResolveFsdType(descriptor.type);\n    const offset = baseOffset + (descriptor.offset ?? 0);\n\n    switch (type)\n    {\n        case CjsFsd64Binary.Type.BOOLEAN:\n            return (binary.Byte(offset) & (1 << (descriptor.bit ?? 0))) !== 0;\n\n        case CjsFsd64Binary.Type.FLOAT_32:\n            return binary.Float32(offset);\n\n        case CjsFsd64Binary.Type.FLOAT_64:\n            return binary.Float64(offset);\n\n        case CjsFsd64Binary.Type.INT_32:\n            return binary.Int32(offset);\n\n        case CjsFsd64Binary.Type.INT_32_IDENTIFIER:\n            return FormatIdentifier(binary.Int32(offset), json);\n\n        case CjsFsd64Binary.Type.LIST:\n            return DecodeList(binary, offset, descriptor, json, path, field);\n\n        case CjsFsd64Binary.Type.MAP:\n            return DecodeMap(binary, offset, descriptor, json, path);\n\n        case CjsFsd64Binary.Type.OBJECT:\n            return DecodeObject(binary, offset, descriptor, json, path);\n\n        case CjsFsd64Binary.Type.STRING:\n            return ReadRequiredString(binary, offset, path, field);\n\n        case CjsFsd64Binary.Type.UINT_8:\n            return binary.Byte(offset);\n\n        case CjsFsd64Binary.Type.UINT_32:\n            return binary.Uint32(offset);\n\n        case CjsFsd64Binary.Type.UINT_32_IDENTIFIER:\n            return FormatIdentifier(binary.Uint32(offset), json);\n\n        case CjsFsd64Binary.Type.UINT_64:\n            return binary.Uint64(offset);\n\n        case CjsFsd64Binary.Type.UINT_64_IDENTIFIER:\n            return json ? binary.Uint64Identity(offset) : binary.Uint64(offset);\n\n        default:\n            throw SchemaError(`Unsupported FSD binary type: ${descriptor.type}`);\n    }\n}\n\nfunction DecodeObject(binary, baseOffset, descriptor, json, path)\n{\n    const flags = descriptor.presence\n        ? DecodeValue(binary, baseOffset, descriptor.presence, false, path, \"<presence>\")\n        : 0;\n\n    if (descriptor.presence)\n    {\n        AssertFlags(flags, descriptor.presence.allowedMask, path);\n    }\n\n    const value = {};\n\n    for (const field of descriptor.fields)\n    {\n        if (field.presenceMask !== undefined && (flags & field.presenceMask) === 0)\n        {\n            continue;\n        }\n\n        DefineValue(value, field.name, DecodeValue(\n            binary,\n            baseOffset,\n            field,\n            json,\n            path,\n            field.name,\n        ));\n    }\n\n    return value;\n}\n\nfunction DecodeList(binary, pointerOffset, descriptor, json, path, field)\n{\n    const relativeOffset = binary.Uint64(pointerOffset);\n    const offsets = binary.ListEntries(\n        relativeOffset,\n        descriptor.itemSize,\n        descriptor.maximumCount ?? Number.MAX_SAFE_INTEGER,\n    );\n\n    return offsets.map(offset => DecodeValue(\n        binary,\n        offset,\n        descriptor.item,\n        json,\n        path,\n        `${field}[]`,\n    ));\n}\n\nfunction DecodeMap(binary, headerOffset, descriptor, json, path)\n{\n    const entries = [];\n\n    for (const recordOffset of binary.MapEntries(descriptor.recordSize, headerOffset))\n    {\n        const key = DecodeValue(binary, recordOffset, descriptor.key, json, path, \"<key>\");\n        const value = descriptor.value\n            ? DecodeValue(binary, recordOffset, descriptor.value, json, path, \"<value>\")\n            : DecodeObject(\n                binary,\n                recordOffset + (descriptor.recordOffset ?? 0),\n                descriptor,\n                json,\n                path,\n            );\n        entries.push([ key, value ]);\n    }\n\n    return json\n        ? CreateJSONObject(entries, path, descriptor.key.type)\n        : CreateMap(entries, path);\n}\n\nfunction FormatIdentifier(value, json)\n{\n    return json ? value.toString(10) : value;\n}\n\nfunction CreateMap(entries, path)\n{\n    const result = new Map();\n\n    for (const [ key, value ] of entries)\n    {\n        if (result.has(key))\n        {\n            throw DuplicateKeyError(key, path);\n        }\n\n        result.set(key, value);\n    }\n\n    return result;\n}\n\nfunction CreateJSONObject(entries, path, keyType)\n{\n    entries.sort(([ left ], [ right ]) => CompareKeys(left, right, keyType));\n    const result = {};\n\n    for (const [ key, value ] of entries)\n    {\n        const property = String(key);\n\n        if (Object.hasOwn(result, property))\n        {\n            throw DuplicateKeyError(property, path);\n        }\n\n        DefineValue(result, property, value);\n    }\n\n    return result;\n}\n\nfunction CompareKeys(left, right, type)\n{\n    if (IsIntegerType(type))\n    {\n        const leftValue = BigInt(left);\n        const rightValue = BigInt(right);\n        return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;\n    }\n\n    const leftValue = String(left);\n    const rightValue = String(right);\n    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;\n}\n\nfunction IsIntegerType(type)\n{\n    return type === CjsFsd64Binary.Type.INT_32 ||\n        type === CjsFsd64Binary.Type.INT_32_IDENTIFIER ||\n        type === CjsFsd64Binary.Type.UINT_8 ||\n        type === CjsFsd64Binary.Type.UINT_32 ||\n        type === CjsFsd64Binary.Type.UINT_32_IDENTIFIER ||\n        type === CjsFsd64Binary.Type.UINT_64 ||\n        type === CjsFsd64Binary.Type.UINT_64_IDENTIFIER;\n}\n\nfunction DefineValue(target, property, value)\n{\n    Object.defineProperty(target, property, {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true,\n    });\n}\n\nfunction DuplicateKeyError(key, path)\n{\n    const error = new Error(`Duplicate FSD map key in ${path}: ${key}`);\n    error.code = \"CJS_FSD_DUPLICATE_KEY\";\n    error.key = key;\n    error.path = path;\n    return error;\n}\n\nfunction ValidateSchema(schema)\n{\n    if (!IsPlainObject(schema) || schema.schema !== SCHEMA_NAME ||\n        schema.schemaVersion !== SCHEMA_VERSION)\n    {\n        throw SchemaError(\n            `FSD binary schema must be ${SCHEMA_NAME} version ${SCHEMA_VERSION}.`,\n        );\n    }\n\n    if (typeof schema.path !== \"string\" || schema.path.trim() === \"\")\n    {\n        throw SchemaError(\"FSD binary schema path must be a non-empty string.\");\n    }\n\n    if (typeof schema.name !== \"string\" || schema.name.trim() === \"\")\n    {\n        throw SchemaError(\"FSD binary schema name must be a non-empty string.\");\n    }\n\n    // 32 characters pin the layout alone, which survives a content change and\n    // another publisher's build; 48 additionally pin one build's content digest.\n    if (typeof schema.schemaID !== \"string\" || !/^(?:[0-9a-f]{32}|[0-9a-f]{48})$/iu.test(schema.schemaID))\n    {\n        throw SchemaError(\"FSD binary schema identity must contain 32 or 48 hexadecimal characters.\");\n    }\n\n    // A schema identity is not a hash of the byte layout alone, so one layout\n    // can carry two of them across publishers. Additional identities are\n    // accepted only where the layout was measured to be the same.\n    if (schema.acceptedSchemaIDs !== undefined)\n    {\n        if (!Array.isArray(schema.acceptedSchemaIDs) ||\n            schema.acceptedSchemaIDs.some(value =>\n                typeof value !== \"string\" || !/^(?:[0-9a-f]{32}|[0-9a-f]{48})$/iu.test(value)))\n        {\n            throw SchemaError(\n                \"FSD binary accepted schema identities must be 32 or 48 hexadecimal characters each.\",\n            );\n        }\n    }\n\n    if (!IsPlainObject(schema.container))\n    {\n        throw SchemaError(\"FSD binary schema root must be a MAP or an OBJECT.\");\n    }\n\n    const rootType = ResolveFsdType(schema.container.type);\n\n    if (rootType !== CjsFsd64Binary.Type.MAP && rootType !== CjsFsd64Binary.Type.OBJECT)\n    {\n        throw SchemaError(\"FSD binary schema root must be a MAP or an OBJECT.\");\n    }\n\n    AssertOffset(schema.container.offset ?? 0, \"container.offset\");\n\n    if (rootType === CjsFsd64Binary.Type.OBJECT)\n    {\n        AssertPositiveInteger(schema.container.headerSize, \"container.headerSize\");\n        ValidateObjectDescriptor(schema.container, schema.container.headerSize, \"container\");\n\n        return;\n    }\n\n    ValidateMapDescriptor(schema.container, \"container\");\n}\n\nfunction ValidateMapDescriptor(descriptor, label)\n{\n    AssertPositiveInteger(descriptor.recordSize, `${label}.recordSize`);\n    ValidateValueDescriptor(descriptor.key, descriptor.recordSize, `${label}.key`);\n\n    if (descriptor.value !== undefined)\n    {\n        if (descriptor.fields !== undefined || descriptor.presence !== undefined ||\n            descriptor.recordOffset !== undefined)\n        {\n            throw SchemaError(`${label} cannot combine value with object record metadata.`);\n        }\n\n        ValidateValueDescriptor(descriptor.value, descriptor.recordSize, `${label}.value`);\n        return;\n    }\n\n    const recordOffset = descriptor.recordOffset ?? 0;\n    AssertOffset(recordOffset, `${label}.recordOffset`);\n\n    if (recordOffset > descriptor.recordSize)\n    {\n        throw SchemaError(`${label}.recordOffset exceeds the record size.`);\n    }\n\n    ValidateObjectDescriptor(\n        descriptor,\n        descriptor.recordSize - recordOffset,\n        label,\n    );\n}\n\nfunction ValidateObjectDescriptor(descriptor, availableSize, label)\n{\n    if (!Array.isArray(descriptor.fields))\n    {\n        throw SchemaError(`${label}.fields must be an array.`);\n    }\n\n    if (descriptor.presence !== undefined)\n    {\n        ValidateValueDescriptor(descriptor.presence, availableSize, `${label}.presence`);\n        const presenceType = ResolveFsdType(descriptor.presence.type);\n\n        if (presenceType !== CjsFsd64Binary.Type.UINT_32 &&\n            presenceType !== CjsFsd64Binary.Type.UINT_64)\n        {\n            throw SchemaError(`${label}.presence must use UINT_32 or UINT_64.`);\n        }\n\n        AssertSafeMask(descriptor.presence.allowedMask, `${label}.presence.allowedMask`);\n    }\n\n    const names = new Set();\n    let previousOffset = -1;\n\n    for (let index = 0; index < descriptor.fields.length; index++)\n    {\n        const field = descriptor.fields[index];\n        const fieldLabel = `${label}.fields[${index}]`;\n        ValidateValueDescriptor(field, availableSize, fieldLabel);\n\n        const offset = field.offset ?? 0;\n\n        if (offset < previousOffset)\n        {\n            throw SchemaError(`${label}.fields must be ordered by byte offset.`);\n        }\n\n        previousOffset = offset;\n\n        if (typeof field.name !== \"string\" || field.name === \"\")\n        {\n            throw SchemaError(`${fieldLabel}.name must be a non-empty string.`);\n        }\n\n        if (names.has(field.name))\n        {\n            throw SchemaError(`FSD binary schema field is duplicated: ${field.name}`);\n        }\n\n        names.add(field.name);\n        ValidateSourceName(field, fieldLabel);\n        ValidatePresenceMask(field, descriptor.presence, fieldLabel);\n    }\n}\n\n/**\n * Converts a client field name to the name the export publishes.\n *\n * The newer datasets name fields in snake_case and CCP's exporter camelCases\n * them, with one wrinkle worth writing down rather than remembering: a trailing\n * `id` segment becomes `ID`, so `type_id` is published as `typeID` and not\n * `typeId`. That rule was applied by hand across the SKINR schemas before it\n * was written anywhere, and by hand it was applied inconsistently.\n *\n * @param {string} sourceName Field name as the client stores it.\n * @returns {string} Field name as the export publishes it.\n */\nexport function CamelizeFieldName(sourceName)\n{\n    return String(sourceName)\n        .split(\"_\")\n        .map((segment, index) =>\n        {\n            if (segment.toLowerCase() === \"id\") return \"ID\";\n\n            return index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1);\n        })\n        .join(\"\");\n}\n\n/**\n * Checks a field's name against the client's own name for it.\n *\n * A schema may record `sourceName`, the name the loader gives the field. When\n * it does, the decoded name must be the mechanical conversion of it - which is\n * what makes the conversion checkable rather than a transcription nobody can\n * audit. A field that departs deliberately, such as a label identifier the\n * export republishes as resolved text, declares `renamed: true` and says why in\n * the reader.\n */\nfunction ValidateSourceName(descriptor, label)\n{\n    if (descriptor.sourceName === undefined) return;\n\n    if (typeof descriptor.sourceName !== \"string\" || descriptor.sourceName === \"\")\n    {\n        throw SchemaError(`${label}.sourceName must be a non-empty string.`);\n    }\n\n    if (descriptor.renamed === true) return;\n\n    const expected = CamelizeFieldName(descriptor.sourceName);\n\n    if (descriptor.name !== expected)\n    {\n        throw SchemaError(\n            `${label} is named ${descriptor.name} but its source ${descriptor.sourceName} `\n            + `converts to ${expected}. Set renamed: true if the departure is deliberate.`,\n        );\n    }\n}\n\nfunction ValidateValueDescriptor(descriptor, availableSize, label)\n{\n    if (!IsPlainObject(descriptor))\n    {\n        throw SchemaError(`${label} must be an object.`);\n    }\n\n    const type = ResolveFsdType(descriptor.type);\n\n    if (type === CjsFsd64Binary.Type.OBJECT)\n    {\n        const offset = descriptor.offset ?? 0;\n        AssertOffset(offset, `${label}.offset`);\n\n        if (offset > availableSize)\n        {\n            throw SchemaError(`${label}.offset exceeds its containing record.`);\n        }\n\n        ValidateObjectDescriptor(descriptor, availableSize - offset, label);\n        return;\n    }\n\n    AssertOffset(descriptor.offset, `${label}.offset`);\n\n    if (descriptor.offset + TYPE_SIZES[type] > availableSize)\n    {\n        throw SchemaError(`${label} exceeds its ${availableSize}-byte record.`);\n    }\n\n    if (type === CjsFsd64Binary.Type.LIST)\n    {\n        AssertPositiveInteger(descriptor.itemSize, `${label}.itemSize`);\n\n        if (descriptor.maximumCount !== undefined)\n        {\n            AssertPositiveInteger(descriptor.maximumCount, `${label}.maximumCount`);\n        }\n\n        ValidateValueDescriptor(descriptor.item, descriptor.itemSize, `${label}.item`);\n    }\n    else if (type === CjsFsd64Binary.Type.MAP)\n    {\n        ValidateMapDescriptor(descriptor, label);\n    }\n}\n\nfunction ValidatePresenceMask(field, presence, label)\n{\n    if (field.presenceMask === undefined)\n    {\n        return;\n    }\n\n    if (!presence)\n    {\n        throw SchemaError(`${label}.presenceMask requires record presence metadata.`);\n    }\n\n    AssertSafeMask(field.presenceMask, `${label}.presenceMask`);\n\n    if (field.presenceMask === 0 ||\n        !Number.isInteger(Math.log2(field.presenceMask)))\n    {\n        throw SchemaError(`${label}.presenceMask must contain exactly one bit.`);\n    }\n\n    if ((field.presenceMask & presence.allowedMask) === 0)\n    {\n        throw SchemaError(`${label}.presenceMask is outside the allowed presence mask.`);\n    }\n}\n\nfunction ResolveFsdType(type)\n{\n    if (typeof type !== \"string\" || !Object.hasOwn(CjsFsd64Binary.Type, type))\n    {\n        throw SchemaError(`Unknown FSD binary type: ${String(type)}`);\n    }\n\n    return CjsFsd64Binary.Type[type];\n}\n\nfunction AssertOffset(value, label)\n{\n    if (!Number.isSafeInteger(value) || value < 0)\n    {\n        throw SchemaError(`${label} must be a non-negative safe integer.`);\n    }\n}\n\nfunction AssertPositiveInteger(value, label)\n{\n    if (!Number.isSafeInteger(value) || value < 1)\n    {\n        throw SchemaError(`${label} must be a positive safe integer.`);\n    }\n}\n\nfunction AssertSafeMask(value, label)\n{\n    if (!Number.isSafeInteger(value) || value < 0)\n    {\n        throw SchemaError(`${label} must be a non-negative safe-integer mask.`);\n    }\n}\n\nfunction IsPlainObject(value)\n{\n    if (value === null || typeof value !== \"object\")\n    {\n        return false;\n    }\n\n    const prototype = Object.getPrototypeOf(value);\n    return prototype === Object.prototype || prototype === null;\n}\n\nfunction SchemaError(message)\n{\n    const error = new TypeError(message);\n    error.code = \"CJS_FSD_BINARY_SCHEMA_INVALID\";\n    return error;\n}\n\nexport default CjsFsd64SchemaDecoder;\n"],"names":["SCHEMA_NAME","SCHEMA_VERSION","TYPE_SIZES","CjsFsd64Binary","Type","BOOLEAN","FLOAT_32","FLOAT_64","INT_32","INT_32_IDENTIFIER","LIST","MAP","STRING","UINT_8","UINT_32","UINT_32_IDENTIFIER","UINT_64","UINT_64_IDENTIFIER","CjsFsd64SchemaDecoder","defineSchema","schema","ValidateSchema","read","bytes","DecodeRoot","readJSON","json","binary","path","schemaID","acceptedSchemaIDs","containerOffset","RootOffset","container","offset","ResolveFsdType","type","OBJECT","DecodeObject","DecodeMap","DecodeValue","baseOffset","descriptor","field","Byte","bit","Float32","Float64","Int32","FormatIdentifier","DecodeList","ReadRequiredString","Uint32","Uint64","Uint64Identity","SchemaError","flags","presence","AssertFlags","allowedMask","value","fields","presenceMask","undefined","DefineValue","name","pointerOffset","relativeOffset","offsets","ListEntries","itemSize","maximumCount","Number","MAX_SAFE_INTEGER","map","item","headerOffset","entries","recordOffset","MapEntries","recordSize","key","push","CreateJSONObject","CreateMap","toString","result","Map","has","DuplicateKeyError","set","keyType","sort","left","right","CompareKeys","property","String","Object","hasOwn","IsIntegerType","leftValue","BigInt","rightValue","target","defineProperty","configurable","enumerable","writable","error","Error","code","IsPlainObject","schemaVersion","trim","test","Array","isArray","some","rootType","AssertOffset","AssertPositiveInteger","headerSize","ValidateObjectDescriptor","ValidateMapDescriptor","label","ValidateValueDescriptor","availableSize","presenceType","AssertSafeMask","names","Set","previousOffset","index","length","fieldLabel","add","ValidateSourceName","ValidatePresenceMask","CamelizeFieldName","sourceName","split","segment","toLowerCase","charAt","toUpperCase","slice","join","renamed","expected","isInteger","Math","log2","isSafeInteger","prototype","getPrototypeOf","message","TypeError"],"mappings":"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"}

package/dist/formats/fsd/64/core/CjsFsd64SchemaReader.js

@@ -0,0 +1,43 @@
+import { CjsFsd64SchemaDecoder } from './CjsFsd64SchemaDecoder.js';
+
+/**
+ * Base class for file-specific readers defined by JSON-shaped JavaScript layouts.
+ */
+class CjsFsd64SchemaReader {
+  /**
+   * Decodes bytes to the existing private Map-based reader representation.
+   */
+  Read(bytes) {
+    return CjsFsd64SchemaDecoder.read(bytes, this.constructor.getFsdSchema());
+  }
+
+  /**
+   * Decodes bytes to a plain JSON-compatible value with lossless identities.
+   */
+  ReadJSON(bytes) {
+    return CjsFsd64SchemaDecoder.readJSON(bytes, this.constructor.getFsdSchema());
+  }
+
+  /** Returns the binary-layout schema owned by a reader class. */
+  static getFsdSchema() {
+    throw new Error("FSD schema reader must define static getFsdSchema().");
+  }
+
+  /** Bind one inline schema to a subclass-owned getFsdSchema function. */
+  static bindFsdSchema(schema) {
+    return () => schema;
+  }
+
+  /** Returns the logical resource path declared by the schema. */
+  static get path() {
+    return this.getFsdSchema().path;
+  }
+
+  /** Returns the binary schema identity declared by the schema. */
+  static get schemaID() {
+    return this.getFsdSchema().schemaID;
+  }
+}
+
+export { CjsFsd64SchemaReader };
+//# sourceMappingURL=CjsFsd64SchemaReader.js.map

package/dist/formats/fsd/64/core/CjsFsd64SchemaReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsFsd64SchemaReader.js","sources":["../../../../../../src/formats/fsd/64/core/CjsFsd64SchemaReader.js"],"sourcesContent":["import { CjsFsd64SchemaDecoder } from \"./CjsFsd64SchemaDecoder.js\";\n\n/**\n * Base class for file-specific readers defined by JSON-shaped JavaScript layouts.\n */\nexport class CjsFsd64SchemaReader\n{\n    /**\n     * Decodes bytes to the existing private Map-based reader representation.\n     */\n    Read(bytes)\n    {\n        return CjsFsd64SchemaDecoder.read(bytes, this.constructor.getFsdSchema());\n    }\n\n    /**\n     * Decodes bytes to a plain JSON-compatible value with lossless identities.\n     */\n    ReadJSON(bytes)\n    {\n        return CjsFsd64SchemaDecoder.readJSON(bytes, this.constructor.getFsdSchema());\n    }\n\n    /** Returns the binary-layout schema owned by a reader class. */\n    static getFsdSchema()\n    {\n        throw new Error(\"FSD schema reader must define static getFsdSchema().\");\n    }\n\n    /** Bind one inline schema to a subclass-owned getFsdSchema function. */\n    static bindFsdSchema(schema)\n    {\n        return () => schema;\n    }\n\n    /** Returns the logical resource path declared by the schema. */\n    static get path()\n    {\n        return this.getFsdSchema().path;\n    }\n\n    /** Returns the binary schema identity declared by the schema. */\n    static get schemaID()\n    {\n        return this.getFsdSchema().schemaID;\n    }\n\n}\n\nexport default CjsFsd64SchemaReader;\n"],"names":["CjsFsd64SchemaReader","Read","bytes","CjsFsd64SchemaDecoder","read","constructor","getFsdSchema","ReadJSON","readJSON","Error","bindFsdSchema","schema","path","schemaID"],"mappings":";;AAEA;AACA;AACA;AACO,MAAMA,oBAAoB,CACjC;AACI;AACJ;AACA;EACIC,IAAIA,CAACC,KAAK,EACV;AACI,IAAA,OAAOC,qBAAqB,CAACC,IAAI,CAACF,KAAK,EAAE,IAAI,CAACG,WAAW,CAACC,YAAY,EAAE,CAAC;AAC7E,EAAA;;AAEA;AACJ;AACA;EACIC,QAAQA,CAACL,KAAK,EACd;AACI,IAAA,OAAOC,qBAAqB,CAACK,QAAQ,CAACN,KAAK,EAAE,IAAI,CAACG,WAAW,CAACC,YAAY,EAAE,CAAC;AACjF,EAAA;;AAEA;EACA,OAAOA,YAAYA,GACnB;AACI,IAAA,MAAM,IAAIG,KAAK,CAAC,sDAAsD,CAAC;AAC3E,EAAA;;AAEA;EACA,OAAOC,aAAaA,CAACC,MAAM,EAC3B;AACI,IAAA,OAAO,MAAMA,MAAM;AACvB,EAAA;;AAEA;EACA,WAAWC,IAAIA,GACf;AACI,IAAA,OAAO,IAAI,CAACN,YAAY,EAAE,CAACM,IAAI;AACnC,EAAA;;AAEA;EACA,WAAWC,QAAQA,GACnB;AACI,IAAA,OAAO,IAAI,CAACP,YAAY,EAAE,CAACO,QAAQ;AACvC,EAAA;AAEJ;;;;"}

package/dist/formats/fsd/64/core/fsd64Records.js

@@ -0,0 +1,60 @@
+import { CjsFsd64Binary } from './CjsFsd64Binary.js';
+
+/** Decodes one map using a caller-supplied fixed-record function. */
+function ReadFsdMap(bytes, options, readRecord) {
+  const binary = new CjsFsd64Binary(bytes, options);
+  const result = new Map();
+  for (const offset of binary.MapEntries(options.recordSize)) {
+    const [key, value] = readRecord(binary, offset);
+    if (result.has(key)) {
+      const error = new Error(`Duplicate FSD map key in ${options.path}: ${key}`);
+      error.code = "CJS_FSD_DUPLICATE_KEY";
+      error.key = key;
+      error.path = options.path;
+      throw error;
+    }
+    result.set(key, value);
+  }
+  return result;
+}
+
+/** Reads a required UTF-8 field and reports its logical field identity on failure. */
+function ReadRequiredString(binary, pointerOffset, path, field) {
+  const value = binary.Utf8StringAtDataPointer(binary.Uint64(pointerOffset));
+  if (value === null) {
+    const error = new Error(`Invalid FSD string for ${path} field ${field}.`);
+    error.code = "CJS_FSD_STRING_INVALID";
+    error.field = field;
+    error.path = path;
+    throw error;
+  }
+  return value;
+}
+
+/** Reads a required string-list field and reports its logical field identity on failure. */
+function ReadRequiredStringList(binary, pointerOffset, path, field, maximumCount = 100) {
+  const value = binary.StringList(binary.Uint64(pointerOffset), maximumCount);
+  if (value === null) {
+    const error = new Error(`Invalid FSD string list for ${path} field ${field}.`);
+    error.code = "CJS_FSD_LIST_INVALID";
+    error.field = field;
+    error.path = path;
+    throw error;
+  }
+  return value;
+}
+
+/** Rejects presence flags outside a reader's supported mask. */
+function AssertFlags(flags, mask, path) {
+  if ((flags & ~mask) !== 0) {
+    const error = new Error(`Unsupported FSD presence flags for ${path}: ${flags}`);
+    error.code = "CJS_FSD_FLAGS_UNSUPPORTED";
+    error.flags = flags;
+    error.mask = mask;
+    error.path = path;
+    throw error;
+  }
+}
+
+export { AssertFlags, ReadFsdMap, ReadRequiredString, ReadRequiredStringList };
+//# sourceMappingURL=fsd64Records.js.map

package/dist/formats/fsd/64/core/fsd64Records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fsd64Records.js","sources":["../../../../../../src/formats/fsd/64/core/fsd64Records.js"],"sourcesContent":["import { CjsFsd64Binary } from \"./CjsFsd64Binary.js\";\n\n/** Decodes one map using a caller-supplied fixed-record function. */\nexport function ReadFsdMap(bytes, options, readRecord)\n{\n    const binary = new CjsFsd64Binary(bytes, options);\n    const result = new Map();\n\n    for (const offset of binary.MapEntries(options.recordSize))\n    {\n        const [ key, value ] = readRecord(binary, offset);\n\n        if (result.has(key))\n        {\n            const error = new Error(`Duplicate FSD map key in ${options.path}: ${key}`);\n            error.code = \"CJS_FSD_DUPLICATE_KEY\";\n            error.key = key;\n            error.path = options.path;\n            throw error;\n        }\n\n        result.set(key, value);\n    }\n\n    return result;\n}\n\n/** Reads a required UTF-8 field and reports its logical field identity on failure. */\nexport function ReadRequiredString(binary, pointerOffset, path, field)\n{\n    const value = binary.Utf8StringAtDataPointer(binary.Uint64(pointerOffset));\n\n    if (value === null)\n    {\n        const error = new Error(`Invalid FSD string for ${path} field ${field}.`);\n        error.code = \"CJS_FSD_STRING_INVALID\";\n        error.field = field;\n        error.path = path;\n        throw error;\n    }\n\n    return value;\n}\n\n/** Reads a required string-list field and reports its logical field identity on failure. */\nexport function ReadRequiredStringList(binary, pointerOffset, path, field, maximumCount = 100)\n{\n    const value = binary.StringList(binary.Uint64(pointerOffset), maximumCount);\n\n    if (value === null)\n    {\n        const error = new Error(`Invalid FSD string list for ${path} field ${field}.`);\n        error.code = \"CJS_FSD_LIST_INVALID\";\n        error.field = field;\n        error.path = path;\n        throw error;\n    }\n\n    return value;\n}\n\n/** Rejects presence flags outside a reader's supported mask. */\nexport function AssertFlags(flags, mask, path)\n{\n    if ((flags & ~mask) !== 0)\n    {\n        const error = new Error(`Unsupported FSD presence flags for ${path}: ${flags}`);\n        error.code = \"CJS_FSD_FLAGS_UNSUPPORTED\";\n        error.flags = flags;\n        error.mask = mask;\n        error.path = path;\n        throw error;\n    }\n}\n"],"names":["ReadFsdMap","bytes","options","readRecord","binary","CjsFsd64Binary","result","Map","offset","MapEntries","recordSize","key","value","has","error","Error","path","code","set","ReadRequiredString","pointerOffset","field","Utf8StringAtDataPointer","Uint64","ReadRequiredStringList","maximumCount","StringList","AssertFlags","flags","mask"],"mappings":"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"}

package/dist/formats/fsd/64/index.js

@@ -0,0 +1,7 @@
+export { CjsFsd64Format, CjsFsd64Format as default } from './CjsFsd64Format.js';
+export { CjsFsd64Binary } from './core/CjsFsd64Binary.js';
+export { CjsFsd64Reader } from './core/CjsFsd64Reader.js';
+export { CjsFsd64SchemaDecoder } from './core/CjsFsd64SchemaDecoder.js';
+export { CjsFsd64SchemaReader } from './core/CjsFsd64SchemaReader.js';
+export { AssertFlags, ReadFsdMap, ReadRequiredString, ReadRequiredStringList } from './core/fsd64Records.js';
+//# sourceMappingURL=index.js.map

package/dist/formats/fsd/64/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/formats/fsd/64/readers/CjsFsd64ReaderSetCharacterStaticData.js

@@ -0,0 +1,33 @@
+import ancestriesReader from './CjsFsd64SchemaAncestries.js';
+import archetypesReader from './CjsFsd64SchemaArchetypes.js';
+import bloodlinesReader from './CjsFsd64SchemaBloodlines.js';
+import characterAvatarBehaviorsReader from './CjsFsd64SchemaCharacterAvatarBehaviors.js';
+import characterColorLocationsReader from './CjsFsd64SchemaCharacterColorLocations.js';
+import characterColorNamesReader from './CjsFsd64SchemaCharacterColorNames.js';
+import characterModifierLocationsReader from './CjsFsd64SchemaCharacterModifierLocations.js';
+import characterPortraitResourcesReader from './CjsFsd64SchemaCharacterPortraitResources.js';
+import characterResourcesReader from './CjsFsd64SchemaCharacterResources.js';
+import characterSculptingLocationsReader from './CjsFsd64SchemaCharacterSculptingLocations.js';
+import paperdollsReader from './CjsFsd64SchemaPaperdolls.js';
+import racesReader from './CjsFsd64SchemaRaces.js';
+
+const CHARACTER_STATIC_DATA_READERS = [ancestriesReader, archetypesReader, bloodlinesReader, characterAvatarBehaviorsReader, characterColorLocationsReader, characterColorNamesReader, characterModifierLocationsReader, characterPortraitResourcesReader, characterResourcesReader, characterSculptingLocationsReader, paperdollsReader, racesReader];
+const CHARACTER_STATIC_DATA_PATHS = CHARACTER_STATIC_DATA_READERS.map(reader => reader.constructor.path);
+
+/**
+ * File-specific character/staticdata readers.
+ */
+class CjsFsd64ReaderSetCharacterStaticData {
+  static create() {
+    return [...CHARACTER_STATIC_DATA_READERS];
+  }
+  static registerAll(registry) {
+    for (const reader of this.create()) {
+      registry.Register(reader.constructor.path, reader);
+    }
+    return registry;
+  }
+}
+
+export { CHARACTER_STATIC_DATA_PATHS, CjsFsd64ReaderSetCharacterStaticData };
+//# sourceMappingURL=CjsFsd64ReaderSetCharacterStaticData.js.map