@kubun/protocol 0.9.0 → 0.11.0

package/lib/models/document.js

@@ -1 +1,550 @@
-import{asType as e,createValidator as t}from"@enkaku/schema";import{DocumentModelID as r,ScalarModelID as o,ShapeModelID as i}from"@kubun/id";import{pascalCase as s}from"change-case";import{baseObjectModel as n,nameString as a,referencesRecordModel as d}from"./json-schema.js";import{binaryStringValue as c,didStringValue as l}from"./value.js";export const documentModelVersion={type:"string",const:"1.0"};export const documentFieldMetaAccount={type:"object",properties:{type:{type:"string",const:"account"},searchable:{type:"boolean"}},required:["type"],additionalProperties:!1};export const documentFieldMetaAttachment={type:"object",properties:{type:{type:"string",const:"attachment"},searchable:{type:"boolean"}},required:["type"],additionalProperties:!1};export const documentFieldMetaDocument={type:"object",properties:{type:{type:"string",const:"document"},model:{anyOf:[{type:"string"},{type:"null"}]},searchable:{type:"boolean"}},required:["type","model"],additionalProperties:!1};export const documentFieldMeta={anyOf:[documentFieldMetaAccount,documentFieldMetaAttachment,documentFieldMetaDocument]};export const documentFieldsMeta={type:"object",additionalProperties:documentFieldMeta};export const documentModelSchema={type:"object",properties:{...n.properties,$defs:d},required:[...n.required,"$defs"],additionalProperties:!1};export const documentModelBase={type:"object",properties:{name:a,version:documentModelVersion,interfaces:{type:"array",items:{type:"string"}},schema:documentModelSchema,fieldsMeta:documentFieldsMeta},required:["name","version","interfaces","schema","fieldsMeta"],additionalProperties:!1};export const documentModelDefault={type:"object",properties:{...documentModelBase.properties,behavior:{type:"string",const:"default"}},required:[...documentModelBase.required,"behavior"],additionalProperties:!1};export const documentModelInterface={type:"object",properties:{...documentModelBase.properties,behavior:{type:"string",const:"interface"}},required:[...documentModelBase.required,"behavior"],additionalProperties:!1};export const documentModelUnique={type:"object",properties:{...documentModelBase.properties,behavior:{type:"string",const:"unique"},uniqueFields:{type:"array",items:{type:"string"}}},required:[...documentModelBase.required,"behavior","uniqueFields"],additionalProperties:!1};export const documentModel={$id:"urn:kubun:protocol:model:document",anyOf:[documentModelDefault,documentModelInterface,documentModelUnique]};export const documentModelsCluster={type:"array",items:documentModel};export const documentModelsRecord={type:"object",additionalProperties:documentModel};export const setDocumentMutation={$id:"urn:kubun:protocol:mutation:set",type:"object",properties:{typ:{type:"string",const:"set"},iss:l,aud:l,sub:{type:"string"},data:{type:"object",additionalProperties:!0},hlc:{type:"string"},unq:c,cap:{anyOf:[{type:"string"},{type:"array",items:{type:"string"}}]}},required:["iss","sub","typ","data","hlc","unq"],additionalProperties:!1};export const patchOperationSchema={type:"object",properties:{op:{type:"string"},path:{type:"string"},value:{},from:{type:"string"}},required:["op","path"],additionalProperties:!1};export const changeDocumentMutation={$id:"urn:kubun:protocol:mutation:change",type:"object",properties:{typ:{type:"string",const:"change"},iss:l,sub:{type:"string"},patch:{type:"array",items:patchOperationSchema},hlc:{type:"string"},cap:{anyOf:[{type:"string"},{type:"array",items:{type:"string"}}]}},required:["iss","sub","typ","patch","hlc"],additionalProperties:!1};export const documentMutation={$id:"urn:kubun:protocol:mutation",anyOf:[setDocumentMutation,changeDocumentMutation]};export const validateDocumentModel=t(documentModel);export const REFERENCE_PREFIX="#/$defs/";let p={type:"object",title:"JSONObject",additionalProperties:!0},u=/^#([0-9]+)$/;export class DocumentModelNormalizer{#e;#t=new Set;#r;#o;#i;#s;#n={};#a={};#d=new Set;#c={};constructor(e){this.#e=e.inputModel,this.#r=e.logger;let t=e.inputModel.schema??{};this.#l(e.interfaceModels),this.#p(t,e.normalizedInterfaceIDs),this.#i=t.$defs??{},this.#s={...t,type:"object",properties:this.#n,required:Array.from(this.#d),additionalProperties:!1,$defs:{...t.$defs,...this.#a}},this.#o=this.#u(),this.#m()}#l(e){for(let t of e){for(let e of t.interfaces)this.#t.add(e);for(let e of t.schema.required)this.#d.add(e);Object.assign(this.#n,t.schema.properties),Object.assign(this.#a,t.schema.$defs),Object.assign(this.#c,t.fieldsMeta??{})}}#p(e,t){for(let e of t)this.#t.add(e);for(let t of e.required??[])this.#d.add(t);Object.assign(this.#n,e.properties??{}),Object.assign(this.#c,this.#e.fieldsMeta??{})}#u(){let e=this.#s,t=Object.entries(e.properties??{});if(0===t.length)throw Error("Document schema must contain at least one property");let r={};for(let[e,o]of t)r[e]={$ref:this.#h(e,o)};return{type:"object",properties:r,additionalProperties:!1,required:e.required??[],$defs:this.#i}}#h(e,t){if(null!=t.$ref){let r=this.#f(t.$ref);return this.#h(e,r)}let r=t.type;if(null==r)throw Error("Invalid schema: missing type");switch(r){case"array":{if(null==t.title)throw Error("Invalid array schema: missing title");if(null==t.items)throw Error("Invalid array schema: missing items");let{default:r,...o}=t;return this.#y({...o,title:s(t.title),items:{$ref:this.#h(e,t.items)}})}case"object":{if(t.additionalProperties)return this.#y(p);if(null==t.title)throw Error("Invalid object schema: missing title");let e=Object.entries(t.properties??{});if(0===e.length)throw Error("Invalid object schema: must contain at least one property");let r={};for(let[t,o]of e)r[t]={$ref:this.#h(t,o)};return this.#y({type:"object",title:s(t.title),properties:r,required:t.required??[],additionalProperties:!1})}default:return this.#M(e,t)}}#f(e){if(!e.startsWith("#"))throw Error(`Invalid reference format: ${e}`);if(e.startsWith(REFERENCE_PREFIX)){let t=e.slice(REFERENCE_PREFIX.length),r=this.#s.$defs?.[t];if(null==r)throw Error(`Reference not found: ${e}`);return r}let t=e.split("/").slice(1),r=this.#s;for(let o of t){if(null==r||"object"!=typeof r)throw Error(`Invalid reference path: ${e}`);if(null==(r=r[o]))throw Error(`Reference not found: ${e}`)}return r}#M(e,t){let r=o.create(t),i=t;if("boolean"===t.type){let{title:e,...r}=t;i=r}else if(null!=t.title){let r=t.title.toLowerCase();"attachmentid"===r?(this.#c[e]={type:"attachment"},i={...t,title:"attachmentid"}):"did"===r?(this.#c[e]={type:"account"},i={...t,title:"did"}):"docid"===r?(null==this.#c[e]&&(this.#r.warn("Missing fieldMeta entry for document reference {fieldKey} of model {inputModel}",{fieldKey:e,inputModel:this.#e}),this.#c[e]={type:"document",model:null}),i={...t,title:"docid"}):i={...t,title:s(t.title)}}return this.#i[r.toString()]=i,`${REFERENCE_PREFIX}${r}`}#y(e){let t=i.create(e);return this.#i[t.toString()]=e,`${REFERENCE_PREFIX}${t}`}#m(){for(let[e,t]of Object.entries(this.#c)){if("document"!==t.type||null===t.model)continue;let o=t.model.match(u);null!=o&&(this.#c[e]={...t,model:r.local(Number.parseInt(o[1],10)).toString()})}}toDocumentModel(){return e(validateDocumentModel,{version:"1.0",behavior:"default",...this.#e,interfaces:Array.from(this.#t),schema:this.#o,fieldsMeta:this.#c})}}
+import { DocumentModelID, ScalarModelID, ShapeModelID } from '@kubun/id';
+import { asType, createValidator } from '@sozai/schema';
+import { pascalCase } from 'change-case';
+import { baseObjectModel, nameString, referencesRecordModel } from './json-schema.js';
+import { binaryStringValue, didStringValue } from './value.js';
+export const documentModelVersion = {
+    type: 'string',
+    const: '1.0'
+};
+export const documentFieldMetaAccount = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            const: 'account'
+        },
+        searchable: {
+            type: 'boolean'
+        }
+    },
+    required: [
+        'type'
+    ],
+    additionalProperties: false
+};
+export const documentFieldMetaAttachment = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            const: 'attachment'
+        },
+        searchable: {
+            type: 'boolean'
+        }
+    },
+    required: [
+        'type'
+    ],
+    additionalProperties: false
+};
+export const documentFieldMetaDocument = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            const: 'document'
+        },
+        model: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ]
+        },
+        searchable: {
+            type: 'boolean'
+        }
+    },
+    required: [
+        'type',
+        'model'
+    ],
+    additionalProperties: false
+};
+export const documentFieldMeta = {
+    anyOf: [
+        documentFieldMetaAccount,
+        documentFieldMetaAttachment,
+        documentFieldMetaDocument
+    ]
+};
+export const documentFieldsMeta = {
+    type: 'object',
+    additionalProperties: documentFieldMeta
+};
+export const documentModelSchema = {
+    type: 'object',
+    properties: {
+        ...baseObjectModel.properties,
+        $defs: referencesRecordModel
+    },
+    required: [
+        ...baseObjectModel.required,
+        '$defs'
+    ],
+    additionalProperties: false
+};
+export const documentModelBase = {
+    type: 'object',
+    properties: {
+        name: nameString,
+        version: documentModelVersion,
+        interfaces: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        schema: documentModelSchema,
+        fieldsMeta: documentFieldsMeta
+    },
+    required: [
+        'name',
+        'version',
+        'interfaces',
+        'schema',
+        'fieldsMeta'
+    ],
+    additionalProperties: false
+};
+export const documentModelDefault = {
+    type: 'object',
+    properties: {
+        ...documentModelBase.properties,
+        behavior: {
+            type: 'string',
+            const: 'default'
+        }
+    },
+    required: [
+        ...documentModelBase.required,
+        'behavior'
+    ],
+    additionalProperties: false
+};
+export const documentModelInterface = {
+    type: 'object',
+    properties: {
+        ...documentModelBase.properties,
+        behavior: {
+            type: 'string',
+            const: 'interface'
+        }
+    },
+    required: [
+        ...documentModelBase.required,
+        'behavior'
+    ],
+    additionalProperties: false
+};
+export const documentModelUnique = {
+    type: 'object',
+    properties: {
+        ...documentModelBase.properties,
+        behavior: {
+            type: 'string',
+            const: 'unique'
+        },
+        uniqueFields: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    },
+    required: [
+        ...documentModelBase.required,
+        'behavior',
+        'uniqueFields'
+    ],
+    additionalProperties: false
+};
+export const documentModel = {
+    $id: 'urn:kubun:protocol:model:document',
+    anyOf: [
+        documentModelDefault,
+        documentModelInterface,
+        documentModelUnique
+    ]
+};
+export const documentModelsCluster = {
+    type: 'array',
+    items: documentModel
+};
+export const documentModelsRecord = {
+    type: 'object',
+    additionalProperties: documentModel
+};
+export const setDocumentMutation = {
+    $id: 'urn:kubun:protocol:mutation:set',
+    type: 'object',
+    properties: {
+        typ: {
+            type: 'string',
+            const: 'set'
+        },
+        iss: didStringValue,
+        aud: didStringValue,
+        sub: {
+            type: 'string'
+        },
+        data: {
+            type: 'object',
+            additionalProperties: true
+        },
+        hlc: {
+            type: 'string'
+        },
+        unq: binaryStringValue,
+        cap: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            ]
+        }
+    },
+    required: [
+        'iss',
+        'sub',
+        'typ',
+        'data',
+        'hlc',
+        'unq'
+    ],
+    additionalProperties: false
+};
+export const patchOperationSchema = {
+    type: 'object',
+    properties: {
+        op: {
+            type: 'string'
+        },
+        path: {
+            type: 'string'
+        },
+        value: {},
+        from: {
+            type: 'string'
+        }
+    },
+    required: [
+        'op',
+        'path'
+    ],
+    additionalProperties: false
+};
+export const changeDocumentMutation = {
+    $id: 'urn:kubun:protocol:mutation:change',
+    type: 'object',
+    properties: {
+        typ: {
+            type: 'string',
+            const: 'change'
+        },
+        iss: didStringValue,
+        sub: {
+            type: 'string'
+        },
+        patch: {
+            type: 'array',
+            items: patchOperationSchema
+        },
+        hlc: {
+            type: 'string'
+        },
+        cap: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            ]
+        }
+    },
+    required: [
+        'iss',
+        'sub',
+        'typ',
+        'patch',
+        'hlc'
+    ],
+    additionalProperties: false
+};
+export const documentMutation = {
+    $id: 'urn:kubun:protocol:mutation',
+    anyOf: [
+        setDocumentMutation,
+        changeDocumentMutation
+    ]
+};
+// Normalization logic
+export const validateDocumentModel = createValidator(documentModel);
+export const REFERENCE_PREFIX = '#/$defs/';
+function toReference(id) {
+    return `${REFERENCE_PREFIX}${id}`;
+}
+const JSONObjectSchema = {
+    type: 'object',
+    title: 'JSONObject',
+    additionalProperties: true
+};
+const LOCAL_ID_REGEXP = /^#([0-9]+)$/;
+// TODO: add fieldsMeta for account and attachment when walking the schema
+export class DocumentModelNormalizer {
+    #inputModel;
+    #interfaces = new Set();
+    #logger;
+    #normalizedSchema;
+    #refs;
+    #root;
+    #schemaProperties = {};
+    #schemaReferences = {};
+    #schemaRequired = new Set();
+    #fieldsMeta = {};
+    constructor(params){
+        this.#inputModel = params.inputModel;
+        this.#logger = params.logger;
+        const inputSchema = params.inputModel.schema ?? {};
+        this.#processInterfaces(params.interfaceModels);
+        this.#processMeta(inputSchema, params.normalizedInterfaceIDs);
+        this.#refs = inputSchema.$defs ?? {};
+        this.#root = {
+            ...inputSchema,
+            type: 'object',
+            properties: this.#schemaProperties,
+            required: Array.from(this.#schemaRequired),
+            additionalProperties: false,
+            $defs: {
+                ...inputSchema.$defs,
+                ...this.#schemaReferences
+            }
+        };
+        this.#normalizedSchema = this.#normalizeSchema();
+        this.#processFieldsMeta();
+    }
+    #processInterfaces(interfaceModels) {
+        // Add interface fields
+        for (const interfaceModel of interfaceModels){
+            for (const interfaceID of interfaceModel.interfaces){
+                this.#interfaces.add(interfaceID);
+            }
+            for (const requiredKey of interfaceModel.schema.required){
+                this.#schemaRequired.add(requiredKey);
+            }
+            Object.assign(this.#schemaProperties, interfaceModel.schema.properties);
+            Object.assign(this.#schemaReferences, interfaceModel.schema.$defs);
+            Object.assign(this.#fieldsMeta, interfaceModel.fieldsMeta ?? {});
+        }
+    }
+    #processMeta(inputSchema, normalizedInterfaceIDs) {
+        for (const interfaceID of normalizedInterfaceIDs){
+            this.#interfaces.add(interfaceID);
+        }
+        for (const requiredKey of inputSchema.required ?? []){
+            this.#schemaRequired.add(requiredKey);
+        }
+        Object.assign(this.#schemaProperties, inputSchema.properties ?? {});
+        Object.assign(this.#fieldsMeta, this.#inputModel.fieldsMeta ?? {});
+    }
+    #normalizeSchema() {
+        const schema = this.#root;
+        const entries = Object.entries(schema.properties ?? {});
+        if (entries.length === 0) {
+            throw new Error('Document schema must contain at least one property');
+        }
+        const properties = {};
+        for (const [key, value] of entries){
+            properties[key] = {
+                $ref: this.#encodeSchema(key, value)
+            };
+        }
+        return {
+            type: 'object',
+            properties,
+            additionalProperties: false,
+            required: schema.required ?? [],
+            $defs: this.#refs
+        };
+    }
+    #encodeSchema(fieldKey, schema) {
+        if (schema.$ref != null) {
+            const resolvedSchema = this.#resolveReference(schema.$ref);
+            return this.#encodeSchema(fieldKey, resolvedSchema);
+        }
+        const type = schema.type;
+        if (type == null) {
+            throw new Error('Invalid schema: missing type');
+        }
+        switch(type){
+            case 'array':
+                {
+                    if (schema.title == null) {
+                        throw new Error('Invalid array schema: missing title');
+                    }
+                    if (schema.items == null) {
+                        throw new Error('Invalid array schema: missing items');
+                    }
+                    const { default: _, ...rest } = schema;
+                    return this.#addShape({
+                        ...rest,
+                        title: pascalCase(schema.title),
+                        items: {
+                            $ref: this.#encodeSchema(fieldKey, schema.items)
+                        }
+                    });
+                }
+            case 'object':
+                {
+                    if (schema.additionalProperties) {
+                        return this.#addShape(JSONObjectSchema);
+                    }
+                    if (schema.title == null) {
+                        throw new Error('Invalid object schema: missing title');
+                    }
+                    const entries = Object.entries(schema.properties ?? {});
+                    if (entries.length === 0) {
+                        throw new Error('Invalid object schema: must contain at least one property');
+                    }
+                    const properties = {};
+                    for (const [key, value] of entries){
+                        properties[key] = {
+                            $ref: this.#encodeSchema(key, value)
+                        };
+                    }
+                    return this.#addShape({
+                        type: 'object',
+                        title: pascalCase(schema.title),
+                        properties,
+                        required: schema.required ?? [],
+                        additionalProperties: false
+                    });
+                }
+            default:
+                return this.#addScalar(fieldKey, schema);
+        }
+    }
+    #resolveReference(ref) {
+        if (!ref.startsWith('#')) {
+            throw new Error(`Invalid reference format: ${ref}`);
+        }
+        // Handle #/$defs/ references
+        if (ref.startsWith(REFERENCE_PREFIX)) {
+            const key = ref.slice(REFERENCE_PREFIX.length);
+            const resolved = this.#root.$defs?.[key];
+            if (resolved == null) {
+                throw new Error(`Reference not found: ${ref}`);
+            }
+            return resolved;
+        }
+        // Handle other JSON Schema references like #/properties/, #/items/, etc.
+        const segments = ref.split('/').slice(1);
+        // biome-ignore lint/suspicious/noExplicitAny: mixed type
+        let current = this.#root;
+        for (const segment of segments){
+            if (current == null || typeof current !== 'object') {
+                throw new Error(`Invalid reference path: ${ref}`);
+            }
+            current = current[segment];
+            if (current == null) {
+                throw new Error(`Reference not found: ${ref}`);
+            }
+        }
+        return current;
+    }
+    #addScalar(fieldKey, schema) {
+        const id = ScalarModelID.create(schema);
+        let normalizedSchema = schema;
+        if (schema.type === 'boolean') {
+            const { title: _, ...rest } = schema;
+            normalizedSchema = rest;
+        } else if (schema.title != null) {
+            const lowerCaseTitle = schema.title.toLowerCase();
+            if (lowerCaseTitle === 'attachmentid') {
+                this.#fieldsMeta[fieldKey] = {
+                    type: 'attachment'
+                };
+                normalizedSchema = {
+                    ...schema,
+                    title: 'attachmentid'
+                };
+            } else if (lowerCaseTitle === 'did') {
+                this.#fieldsMeta[fieldKey] = {
+                    type: 'account'
+                };
+                normalizedSchema = {
+                    ...schema,
+                    title: 'did'
+                };
+            } else if (lowerCaseTitle === 'docid') {
+                if (this.#fieldsMeta[fieldKey] == null) {
+                    this.#logger.warn('Missing fieldMeta entry for document reference {fieldKey} of model {inputModel}', {
+                        fieldKey,
+                        inputModel: this.#inputModel
+                    });
+                    this.#fieldsMeta[fieldKey] = {
+                        type: 'document',
+                        model: null
+                    };
+                }
+                normalizedSchema = {
+                    ...schema,
+                    title: 'docid'
+                };
+            } else {
+                normalizedSchema = {
+                    ...schema,
+                    title: pascalCase(schema.title)
+                };
+            }
+        }
+        this.#refs[id.toString()] = normalizedSchema;
+        return toReference(id);
+    }
+    #addShape(schema) {
+        const id = ShapeModelID.create(schema);
+        this.#refs[id.toString()] = schema;
+        return toReference(id);
+    }
+    #processFieldsMeta() {
+        // Convert model relations by index to local IDs
+        for (const [key, field] of Object.entries(this.#fieldsMeta)){
+            if (field.type !== 'document' || field.model === null) {
+                continue;
+            }
+            const match = field.model.match(LOCAL_ID_REGEXP);
+            if (match != null) {
+                this.#fieldsMeta[key] = {
+                    ...field,
+                    model: DocumentModelID.local(Number.parseInt(match[1], 10)).toString()
+                };
+            }
+        }
+    }
+    toDocumentModel() {
+        return asType(validateDocumentModel, {
+            version: '1.0',
+            behavior: 'default',
+            ...this.#inputModel,
+            interfaces: Array.from(this.#interfaces),
+            schema: this.#normalizedSchema,
+            fieldsMeta: this.#fieldsMeta
+        });
+    }
+}

package/lib/models/graph.js

@@ -1 +1,55 @@
-import{verifyCluster as e}from"./cluster.js";export class GraphModel{static fromClusters(s){let r={};for(let a of Object.values(s.clusters).map(e))Object.assign(r,a);return new GraphModel({aliases:s.aliases,record:r})}#e;#s;constructor(e){null!=e.aliases&&0!==Object.keys(e.aliases).length?this.#e=e.aliases:this.#e=Object.entries(e.record).reduce((e,[s,r])=>(null==e[r.name]?e[r.name]=s:console.warn(`Duplicate model name ${r.name} in GraphModel record, ignoring model ID ${s} in aliases`),e),{}),this.#s=e.record}get aliases(){return this.#e}get record(){return this.#s}getAlias(e){for(let[s,r]of Object.entries(this.#e))if(r===e)return s;return null}getModel(e){let s=this.#e[e]??e;return this.#s[s]??null}toJSON(){return{aliases:this.#e,record:this.#s}}}
+import { verifyCluster } from './cluster.js';
+export class GraphModel {
+    static fromClusters(params) {
+        const record = {};
+        for (const clusterRecord of Object.values(params.clusters).map(verifyCluster)){
+            Object.assign(record, clusterRecord);
+        }
+        return new GraphModel({
+            aliases: params.aliases,
+            record
+        });
+    }
+    #aliases;
+    #record;
+    constructor(params){
+        if (params.aliases != null && Object.keys(params.aliases).length !== 0) {
+            this.#aliases = params.aliases;
+        } else {
+            // If no aliases are provided, fallback to using the model names
+            this.#aliases = Object.entries(params.record).reduce((acc, [id, model])=>{
+                if (acc[model.name] == null) {
+                    acc[model.name] = id;
+                } else {
+                    console.warn(`Duplicate model name ${model.name} in GraphModel record, ignoring model ID ${id} in aliases`);
+                }
+                return acc;
+            }, {});
+        }
+        this.#record = params.record;
+    }
+    get aliases() {
+        return this.#aliases;
+    }
+    get record() {
+        return this.#record;
+    }
+    getAlias(modelID) {
+        for (const [alias, id] of Object.entries(this.#aliases)){
+            if (id === modelID) {
+                return alias;
+            }
+        }
+        return null;
+    }
+    getModel(aliasOrID) {
+        const id = this.#aliases[aliasOrID] ?? aliasOrID;
+        return this.#record[id] ?? null;
+    }
+    toJSON() {
+        return {
+            aliases: this.#aliases,
+            record: this.#record
+        };
+    }
+}

package/lib/models/group.js

@@ -1 +1 @@
-export{};
+export { };

package/lib/models/json-schema.d.ts

@@ -1,4 +1,4 @@
-import type { FromSchema } from '@enkaku/schema';
+import type { FromSchema } from '@sozai/schema';
 export declare const booleanModel: {
     readonly type: "object";
     readonly properties: {