@underpostnet/cyberia 3.2.80

package/src/api/instance/instance.controller.js

@@ -0,0 +1,8 @@
+import { buildCrudController, serviceHandler } from '../../server/middlewares.js';
+import { InstanceService } from './instance.service.js';
+
+const InstanceController = buildCrudController(InstanceService, {
+  get: serviceHandler(InstanceService.get),
+});
+
+export { InstanceController };

package/src/api/instance/instance.model.js

@@ -0,0 +1,34 @@
+import { Schema, model, Types } from 'mongoose';
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+const InstanceSchema = new Schema(
+  {
+    deployId: { type: String },
+    host: { type: String },
+    path: { type: String },
+    port: { type: String },
+    client: { type: String },
+    runtime: { type: String },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+    apis: [{ type: String }],
+  },
+  {
+    timestamps: true,
+  },
+);
+class InstanceDto {
+  static populate = {
+    get: () => {
+      return {
+        path: 'userId',
+        model: 'User',
+        select: '_id email',
+      };
+    },
+  };
+}
+const InstanceModel = model('Instance', InstanceSchema);
+const ProviderSchema = InstanceSchema;
+export { InstanceSchema, InstanceModel, ProviderSchema, InstanceDto };

package/src/api/instance/instance.router.js

@@ -0,0 +1,27 @@
+import express from 'express';
+import { adminGuard } from '../../server/auth.js';
+import { InstanceController } from './instance.controller.js';
+
+class InstanceRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    const adminOnly = [options.authMiddleware, adminGuard];
+    router.post(`/:id`, ...adminOnly, async (req, res) => await InstanceController.post(req, res, options));
+    router.post(`/`, ...adminOnly, async (req, res) => await InstanceController.post(req, res, options));
+    router.get(`/:id`, ...adminOnly, async (req, res) => await InstanceController.get(req, res, options));
+    router.get(`/`, options.authMiddleware, async (req, res) => await InstanceController.get(req, res, options));
+    router.put(`/:id`, ...adminOnly, async (req, res) => await InstanceController.put(req, res, options));
+    router.put(`/`, ...adminOnly, async (req, res) => await InstanceController.put(req, res, options));
+    router.delete(`/:id`, ...adminOnly, async (req, res) => await InstanceController.delete(req, res, options));
+    router.delete(`/`, ...adminOnly, async (req, res) => await InstanceController.delete(req, res, options));
+    return router;
+  }
+}
+
+const ApiRouter = (options) => InstanceRouter.router(options);
+
+export { ApiRouter, InstanceRouter };

package/src/api/instance/instance.service.js

@@ -0,0 +1,75 @@
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+import { InstanceDto } from './instance.model.js';
+
+const logger = loggerFactory(import.meta);
+
+class InstanceService {
+  static post = async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProviderService.getModel("Instance", options);
+    return await new Instance(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProviderService.getModel("Instance", options);
+
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProviderService.getModel("User", options);
+
+    const user = await User.findOne({
+      _id: req.auth.user._id,
+    });
+    switch (req.params.id) {
+      case 'count': {
+        switch (user.role) {
+          case 'admin':
+            return { total: await Instance.countDocuments() };
+          default:
+            return { total: await Instance.countDocuments({ userId: req.auth.user._id }) };
+        }
+      }
+      default:
+        // Use DataQuery.parse for filtering, sorting, and pagination
+        const defaultSort = { updatedAt: -1 };
+        const baseQuery = user.role === 'admin' ? {} : { userId: req.auth.user._id };
+        const { query, sort, skip, limit, page } = DataQuery.parse({
+          ...req.query,
+          query: baseQuery,
+        });
+
+        // Apply default sort if no sort was specified
+        const finalSort = Object.keys(sort).length > 0 ? sort : defaultSort;
+
+        switch (user.role) {
+          case 'admin':
+            if (req.params.id) return await Instance.findById(req.params.id);
+            const [dataAdmin, totalAdmin] = await Promise.all([
+              Instance.find(query).sort(finalSort).limit(limit).skip(skip).populate(InstanceDto.populate.get()),
+              Instance.countDocuments(query),
+            ]);
+            return { data: dataAdmin, total: totalAdmin, page, totalPages: Math.ceil(totalAdmin / limit) };
+          default:
+            const [dataUser, totalUser] = await Promise.all([
+              Instance.find(query).sort(finalSort).limit(limit).skip(skip).populate(InstanceDto.populate.get()),
+              Instance.countDocuments(query),
+            ]);
+            return { data: dataUser, total: totalUser, page, totalPages: Math.ceil(totalUser / limit) };
+        }
+    }
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProviderService.getModel("Instance", options);
+    return await Instance.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProviderService.getModel("Instance", options);
+    if (req.params.id) return await Instance.findByIdAndDelete(req.params.id);
+    else return await Instance.deleteMany();
+  };
+}
+
+export { InstanceService };

package/src/api/ipfs/ipfs.controller.js

@@ -0,0 +1,8 @@
+import { buildCrudController, serviceHandler } from '../../server/middlewares.js';
+import { IpfsService } from './ipfs.service.js';
+
+const IpfsController = buildCrudController(IpfsService, {
+  verify: serviceHandler(IpfsService.verify),
+});
+
+export { IpfsController };

package/src/api/ipfs/ipfs.model.js

@@ -0,0 +1,77 @@
+/**
+ * Mongoose model for the IPFS CID Registry.
+ *
+ * Purpose: tracks every CID that the Engine has pinned to IPFS so that:
+ *   1. Deletions can cleanly unpin the right CID from the IPFS node/cluster.
+ *   2. Admins can run a health-check that verifies every DB-registered CID is
+ *      still actually pinned (GET /ipfs/verify).
+ *   3. Garbage-collection jobs can discover orphaned CIDs (pinned on the node
+ *      but not referenced by any DB document).
+ *
+ * Fields:
+ *   cid          - IPFS Content Identifier (CIDv0 or CIDv1).
+ *   resourceType - What kind of asset this CID belongs to:
+ *                    'object-layer-data'  - JSON payload of an ObjectLayer document.
+ *                    'atlas-sprite-sheet' - PNG sprite-sheet of an ObjectLayer.
+ *                    'atlas-metadata'     - JSON metadata of an AtlasSpriteSheet.
+ *   mfsPath      - MFS (Mutable File System) path used when the CID was added,
+ *                  e.g. /object-layer/sword/sword_data.json.
+ *                  Enables targeted removal via files/rm without knowing the CID.
+ *                  Uniquely identifies an item-id asset: exactly one registry
+ *                  record per non-empty mfsPath. Distinct item-ids (mfsPaths) may
+ *                  still resolve to the same CID — this is expected for
+ *                  consolidated atlas sprite-sheet PNGs shared across item-ids.
+ *
+ * @module src/api/ipfs/ipfs.model.js
+ * @namespace IpfsModel
+ */
+import { Schema, model } from 'mongoose';
+const IpfsSchema = new Schema(
+  {
+    cid: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    // Asset category - determines which service owns this CID.
+    resourceType: {
+      type: String,
+      required: true,
+      trim: true,
+      enum: ['object-layer-data', 'atlas-sprite-sheet', 'atlas-metadata'],
+    },
+    // MFS path used when the content was added to IPFS.
+    // Empty string when the content was added without an MFS copy.
+    mfsPath: {
+      type: String,
+      default: '',
+      trim: true,
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+// One DB record per item-id asset path. A CID may be shared across several
+// mfsPaths (consolidated atlas sprite-sheets), so the CID itself is not unique.
+// Partial filter keeps the constraint scoped to real (non-empty) MFS paths.
+IpfsSchema.index({ mfsPath: 1 }, { unique: true, partialFilterExpression: { mfsPath: { $gt: '' } } });
+// Fast look-ups for health-check and garbage-collection by type.
+IpfsSchema.index({ resourceType: 1 });
+// Fast unpin look-ups by CID (non-unique: shared across sprite-sheet item-ids).
+IpfsSchema.index({ cid: 1 });
+const IpfsModel = model('Ipfs', IpfsSchema);
+const ProviderSchema = IpfsSchema;
+class IpfsDto {
+  static select = {
+    get: () => ({
+      _id: 1,
+      cid: 1,
+      resourceType: 1,
+      mfsPath: 1,
+      createdAt: 1,
+      updatedAt: 1,
+    }),
+  };
+}
+export { IpfsSchema, IpfsModel, ProviderSchema, IpfsDto };

package/src/api/ipfs/ipfs.router.js

@@ -0,0 +1,26 @@
+import express from 'express';
+import { registerCrudRoutes } from '../../server/middlewares.js';
+import { adminGuard } from '../../server/auth.js';
+import { IpfsController } from './ipfs.controller.js';
+
+class IpfsRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    const adminOnly = [options.authMiddleware, adminGuard];
+    // Health / audit — must come before /:id to avoid matching conflicts.
+    router.get(`/verify`, ...adminOnly, async (req, res) => await IpfsController.verify(req, res, options));
+    return registerCrudRoutes(router, IpfsController, options, {
+      readGuards: adminOnly,
+      writeGuards: adminOnly,
+      deleteAllGuards: adminOnly,
+    });
+  }
+}
+
+const ApiRouter = (options) => IpfsRouter.router(options);
+
+export { ApiRouter, IpfsRouter };

package/src/api/ipfs/ipfs.service.js

@@ -0,0 +1,145 @@
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+import { IpfsClient } from '../../projects/cyberia/ipfs-client.js';
+import { IpfsDto } from './ipfs.model.js';
+const logger = loggerFactory(import.meta);
+/**
+ * Upsert a CID registry entry.
+ * Called by asset services (ObjectLayer, AtlasSpriteSheet) after a successful
+ * IPFS pin so the registry always reflects what is actually pinned.
+ *
+ * @param {object} opts
+ * @param {string} opts.cid          - IPFS Content Identifier.
+ * @param {string} opts.resourceType - Asset category ('object-layer-data' | 'atlas-sprite-sheet' | 'atlas-metadata').
+ * @param {string} [opts.mfsPath]    - MFS path used when adding the content.
+ * @param {object} opts.options      - Router options ({ host, path }) for DB lookup.
+ * @returns {Promise<import('mongoose').Document>}
+ */
+const createPinRecord = async ({ cid, resourceType, mfsPath = '', options }) => {
+  const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+  // mfsPath uniquely identifies an item-id asset, so it is the upsert key: a new
+  // CID arriving for the same path overwrites the previous association (last write
+  // wins). Only content added without an MFS copy falls back to cid+resourceType.
+  const filter = mfsPath ? { mfsPath } : { cid, resourceType };
+  const update = { $set: { cid, resourceType, mfsPath } };
+  try {
+    const record = await Ipfs.findOneAndUpdate(filter, update, {
+      upsert: true,
+      returnDocument: 'after',
+      setDefaultsOnInsert: true,
+    });
+    logger.info(`IPFS registry upserted – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
+    return record;
+  } catch (err) {
+    if (err?.code === 11000) {
+      const record = await Ipfs.findOneAndUpdate(filter, update, { returnDocument: 'after' });
+      logger.info(`IPFS registry reconciled (duplicate key) – CID: ${cid}, type: ${resourceType}, mfsPath: ${mfsPath}`);
+      return record;
+    }
+    throw err;
+  }
+};
+/**
+ * Remove all DB registry entries for a CID, then best-effort unpin from the IPFS node.
+ * Always deletes DB records first so the registry stays clean even if the node is down.
+ *
+ * @param {string} cid     - IPFS Content Identifier to remove.
+ * @param {object} options - Router options ({ host, path }) for DB lookup.
+ * @returns {Promise<void>}
+ */
+const removePinRecordsAndUnpin = async (cid, options) => {
+  const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+  await Ipfs.deleteMany({ cid });
+  logger.info(`Removed IPFS registry entries for CID: ${cid}`);
+  try {
+    await IpfsClient.unpinCid(cid);
+  } catch (err) {
+    logger.warn(`Best-effort IPFS unpin failed for CID ${cid}: ${err.message}`);
+  }
+};
+class IpfsService {
+  /** Expose helpers so other modules can import them directly. */
+  static createPinRecord = createPinRecord;
+  static removePinRecordsAndUnpin = removePinRecordsAndUnpin;
+  // ──────────────────────────────────────────────
+  //  Standard CRUD
+  // ──────────────────────────────────────────────
+  static post = async (req, res, options) => {
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+    return await new Ipfs(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+    if (req.params.id) {
+      return await Ipfs.findById(req.params.id).select(IpfsDto.select.get());
+    }
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+    const [data, total] = await Promise.all([
+      Ipfs.find(query).select(IpfsDto.select.get()).sort(sort).limit(limit).skip(skip),
+      Ipfs.countDocuments(query),
+    ]);
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+    return await Ipfs.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
+  };
+  static delete = async (req, res, options) => {
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+    if (req.params.id) {
+      const record = await Ipfs.findById(req.params.id);
+      if (record) {
+        await Ipfs.findByIdAndDelete(req.params.id);
+        // Only unpin from the node when no other registry entries reference this CID.
+        const remaining = await Ipfs.countDocuments({ cid: record.cid });
+        if (remaining === 0) {
+          try {
+            await IpfsClient.unpinCid(record.cid);
+          } catch (err) {
+            logger.warn(`Failed to unpin CID ${record.cid}: ${err.message}`);
+          }
+        }
+        return record;
+      }
+      return null;
+    }
+    return await Ipfs.deleteMany();
+  };
+  // ──────────────────────────────────────────────
+  //  Health / audit
+  // ──────────────────────────────────────────────
+  /**
+   * GET /ipfs/verify
+   *
+   * Iterates every CID in the registry and checks whether it is actually pinned
+   * on the connected IPFS node. Returns a summary suitable for admin dashboards
+   * and automated alerting.
+   *
+   * Response shape:
+   *   { total, pinned, unpinned, errors, entries: [{ cid, resourceType, mfsPath, pinned, error? }] }
+   */
+  static verify = async (req, res, options) => {
+    const Ipfs = DataBaseProviderService.getModel('Ipfs', options);
+    const records = await Ipfs.find({}).select(IpfsDto.select.get()).lean();
+    let pinned = 0;
+    let unpinned = 0;
+    let errors = 0;
+    const entries = await Promise.all(
+      records.map(async (r) => {
+        try {
+          const isPinned = await IpfsClient.isCidPinned(r.cid);
+          if (isPinned) pinned++;
+          else unpinned++;
+          return { cid: r.cid, resourceType: r.resourceType, mfsPath: r.mfsPath, pinned: isPinned };
+        } catch (err) {
+          errors++;
+          return { cid: r.cid, resourceType: r.resourceType, mfsPath: r.mfsPath, pinned: false, error: err.message };
+        }
+      }),
+    );
+    return { total: records.length, pinned, unpinned, errors, entries };
+  };
+}
+export { IpfsService, createPinRecord, removePinRecordsAndUnpin };

package/src/api/object-layer/object-layer.controller.js

@@ -0,0 +1,18 @@
+import { buildCrudController, controllerHandler, sendBlob, serviceHandler } from '../../server/middlewares.js';
+import { ObjectLayerService } from './object-layer.service.js';
+
+const ObjectLayerController = buildCrudController(ObjectLayerService, {
+  get: serviceHandler(ObjectLayerService.get, { crossOrigin: true }),
+  generateWebp: controllerHandler(async (req, res, options) => {
+    const buffer = await ObjectLayerService.generateWebp(req, res, options);
+    const { itemType, itemId, directionCode } = req.params;
+    return sendBlob(req, res, {
+      buffer,
+      mimetype: 'image/webp',
+      filename: `${itemType}_${itemId}_${directionCode}.webp`,
+      disposition: 'attachment',
+    });
+  }),
+});
+
+export { ObjectLayerController };

package/src/api/object-layer/object-layer.model.js

@@ -0,0 +1,200 @@
+/**
+ * Mongoose model for ObjectLayer API, defining schema, indexes, and data validation.
+ * @module src/api/object-layer/object-layer.model.js
+ * @namespace CyberiaObjectLayerModel
+ */
+import { Schema, model } from 'mongoose';
+/**
+ * @typedef {Object} Stats
+ * @property {number} effect - The effect attribute value
+ * @property {number} resistance - The resistance attribute value
+ * @property {number} agility - The agility attribute value
+ * @property {number} range - The range attribute value
+ * @property {number} intelligence - The intelligence attribute value
+ * @property {number} utility - The utility attribute value
+ * @memberof CyberiaObjectLayerModel
+ */
+const StatsSchema = new Schema(
+  {
+    effect: { type: Number, required: true, min: 0 },
+    resistance: { type: Number, required: true, min: 0 },
+    agility: { type: Number, required: true, min: 0 },
+    range: { type: Number, required: true, min: 0 },
+    intelligence: { type: Number, required: true, min: 0 },
+    utility: { type: Number, required: true, min: 0 },
+  },
+  { _id: false },
+);
+/**
+ * @typedef {Object} Item
+ * @property {string} id - Unique identifier for the item
+ * @property {string} type - Type of the item
+ * @property {string} description - Description of the item
+ * @property {boolean} activable - Whether the item can be activated
+ * @memberof CyberiaObjectLayerModel
+ */
+const ItemSchema = new Schema(
+  {
+    id: { type: String, required: true, trim: true },
+    type: { type: String, required: true, trim: true },
+    description: { type: String, default: '', trim: true },
+    activable: { type: Boolean, default: false },
+  },
+  { _id: false },
+);
+/**
+ * @typedef {Object} Ledger
+ * Blockchain protocol metadata linking the visual object-layer prefab to its economic reality.
+ * Uses ERC-1155 as the single multi-token standard for both fungible (CryptoKoyn) and
+ * non-fungible / semi-fungible Object Layer items within one contract.
+ * @property {string} type - The token standard or off-chain designation (ERC1155, OFF_CHAIN).
+ * @property {string} address - The Solidity smart contract address (ObjectLayerToken).
+ * @property {string} tokenId - The uint256 ERC-1155 token ID (derived from keccak256 of the item identifier).
+ * @memberof CyberiaObjectLayerModel
+ */
+const LedgerSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: ['ERC1155', 'OFF_CHAIN'],
+      required: true,
+    },
+    address: { type: String }, // ObjectLayerToken ERC-1155 contract address
+    tokenId: { type: String, default: '' }, // uint256 ERC-1155 token ID (hex or decimal string)
+  },
+  { _id: false },
+);
+/**
+ * @typedef {Object} Render
+ * IPFS content identifiers for the consolidated atlas sprite sheet.
+ * @property {string} cid - IPFS Content Identifier for the consolidated atlas sprite sheet PNG
+ * @property {string} metadataCid - IPFS Content Identifier for the atlas sprite sheet metadata JSON (fast-json-stable-stringify)
+ * @memberof CyberiaObjectLayerModel
+ */
+const RenderSchema = new Schema(
+  {
+    cid: { type: String, default: '', trim: true },
+    metadataCid: { type: String, default: '', trim: true },
+  },
+  { _id: false },
+);
+/**
+ * @typedef {Object} ObjectLayer
+ * @property {Object} data - Object layer data
+ * @property {Object} data.stats - Statistical or mechanical attributes for the object layer
+ * @property {number} data.stats.effect - The effect attribute value
+ * @property {number} data.stats.resistance - The resistance attribute value
+ * @property {number} data.stats.agility - The agility attribute value
+ * @property {number} data.stats.range - The range attribute value
+ * @property {number} data.stats.intelligence - The intelligence attribute value
+ * @property {number} data.stats.utility - The utility attribute value
+ * @property {Object} data.item - Human-readable item information for the object layer
+ * @property {string} data.item.id - Unique identifier for the item
+ * @property {string} data.item.type - Type of the item
+ * @property {string} data.item.description - Description of the item
+ * @property {boolean} data.item.activable - Whether the item can be activated
+ * @property {Object} data.ledger - Blockchain protocol metadata linking the visual object-layer prefab to its economic reality
+ * @property {string} data.ledger.type - The token standard or off-chain designation (ERC1155, OFF_CHAIN).
+ * @property {string} data.ledger.address - The ObjectLayerToken ERC-1155 smart contract address.
+ * @property {string} data.ledger.tokenId - The uint256 ERC-1155 token ID (hex or decimal string).
+ * @property {Object} data.render - IPFS content identifiers for the consolidated atlas sprite sheet
+ * @property {string} data.render.cid - IPFS Content Identifier for the consolidated atlas sprite sheet PNG
+ * @property {string} data.render.metadataCid - IPFS Content Identifier for the atlas sprite sheet metadata JSON (fast-json-stable-stringify)
+ * @property {string} cid - IPFS Content Identifier for the object layer data JSON (fast-json-stable-stringify)
+ * @property {Types.ObjectId} objectLayerRenderFramesId - Reference to ObjectLayerRenderFrames document
+ * @property {Types.ObjectId} atlasSpriteSheetId - Reference to AtlasSpriteSheet document
+ * @property {string} sha256 - SHA-256 hash of the object layer data
+ * @property {Date} createdAt - When the document was created
+ * @property {Date} updatedAt - When the document was last updated
+ * @memberof CyberiaObjectLayerModel
+ */
+const ObjectLayerSchema = new Schema(
+  {
+    data: {
+      stats: { type: StatsSchema, required: true },
+      item: { type: ItemSchema, required: true },
+      ledger: { type: LedgerSchema, required: true },
+      render: { type: RenderSchema, default: () => ({}) },
+    },
+    cid: { type: String, default: '', trim: true },
+    objectLayerRenderFramesId: { type: Schema.Types.ObjectId, ref: 'ObjectLayerRenderFrames' },
+    atlasSpriteSheetId: { type: Schema.Types.ObjectId, ref: 'AtlasSpriteSheet' },
+    sha256: {
+      type: String,
+      required: true,
+      unique: true,
+      match: [/^[a-f0-9]{64}$/, 'Please provide a valid SHA-256 hash'],
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  },
+);
+// Index for faster querying
+ObjectLayerSchema.index({ 'data.item.id': 1 });
+ObjectLayerSchema.index({ 'data.item.type': 1 });
+// Add text index for searchable fields
+ObjectLayerSchema.index(
+  {
+    'data.item.id': 'text',
+    'data.item.type': 'text',
+    'data.item.description': 'text',
+  },
+  {
+    weights: {
+      'data.item.id': 10,
+      'data.item.type': 5,
+      'data.item.description': 1,
+    },
+  },
+);
+// Pre-save hook to ensure data consistency
+ObjectLayerSchema.pre('save', function () {
+  // Ensure all required fields are present
+  if (!this.data.stats || !this.data.item || !this.sha256) {
+    throw new Error('Missing required fields');
+  }
+  // cid (object layer data JSON) and data.render.cid (atlas PNG) are optional – default to ''
+});
+// Create and export the model
+const ObjectLayerModel = model('ObjectLayer', ObjectLayerSchema);
+const ProviderSchema = ObjectLayerSchema;
+class ObjectLayerDto {
+  static select = {
+    get: () => {
+      return {
+        _id: 1,
+        'data.item': 1,
+        'data.ledger': 1,
+        'data.render': 1,
+        cid: 1,
+        objectLayerRenderFramesId: 1,
+        atlasSpriteSheetId: 1,
+      };
+    },
+    getMetadata: () => {
+      return {
+        _id: 1,
+        'data.item': 1,
+        'data.stats': 1,
+        'data.ledger': 1,
+        'data.render': 1,
+        cid: 1,
+        objectLayerRenderFramesId: 1,
+        atlasSpriteSheetId: 1,
+        sha256: 1,
+        createdAt: 1,
+        updatedAt: 1,
+      };
+    },
+    getRender: () => {
+      return {
+        _id: 1,
+        objectLayerRenderFramesId: 1,
+      };
+    },
+  };
+}
+export { ObjectLayerSchema, ObjectLayerModel, ProviderSchema, ObjectLayerDto };