@syncbridge/common 1.1.4 → 2.0.1

package/registry/package-manifest.d.ts

@@ -1,14 +1,45 @@
+import type { AppMetadata, ComponentMetadata, PluginMetadata } from '../models/index.js';
+/** The file an extension package's manifest is in, at its root */
+export declare const MANIFEST_FILE = "syncbridge-manifest.json";
 /**
- * The `syncbridge` field of an extension package's `package.json`.
+ * An extension package's manifest: what it brings and what it needs.
+ *
+ * Its author writes `name` and `dependencies`, in the `syncbridge` field of
+ * `package.json` or in `syncbridge-manifest.json` at the package's root -
+ * never both. `syncbuild` adds what the package brings and writes the
+ * manifest of the package it builds to `syncbridge-manifest.json` only, so
+ * an installed package's manifest is always that file.
+ *
+ * Fields SyncBridge does not know are passed over with a warning: one added
+ * later breaks neither an older SyncBridge nor an older package.
  */
 export interface SyncBridgeManifest {
     /** The name the package registers under, when it differs from `name` */
     name?: string;
     /** Registry packages this one depends on: registry name -> semver range */
     dependencies?: Record<string, string>;
-    components?: string[];
-    processors?: string[];
+    /** The apps the package brings, each with its definition */
+    apps?: ManifestEntry<AppMetadata>[];
+    /** The components the package brings, each with its definition */
+    components?: ManifestEntry<ComponentMetadata>[];
+    /** The plugins the package brings, each with its definition */
+    plugins?: ManifestEntry<PluginMetadata>[];
+    /**
+     * The language of its documents that name none (README.md, not
+     * README.tr.md): ISO 639-1, its region if any - `en` when not told
+     */
+    docsLanguage?: string;
 }
+/**
+ * Something a package brings: its definition, and where its class is - the
+ * module it is exported from, so a worker loads only what it runs
+ */
+export type ManifestEntry<T> = T & {
+    /** The name the class is exported under from its module */
+    exportName: string;
+    /** Its module, relative to the package's root: `./hl7-bridge.app.js` */
+    entryPoint: string;
+};
 /**
  * The parts of an extension package's `package.json` SyncBridge reads.
  */
@@ -22,3 +53,23 @@ export interface ExtensionPackageJson {
     peerDependencies?: Record<string, string>;
     syncbridge?: SyncBridgeManifest;
 }
+/** A package's manifest as read, with where it was and what was not known */
+export interface ReadManifest {
+    manifest: SyncBridgeManifest;
+    /** `file`: syncbridge-manifest.json; `package.json`: its syncbridge field */
+    source: 'file' | 'package.json';
+    /** Fields of the manifest SyncBridge does not know, passed over */
+    unknownFields: string[];
+}
+/**
+ * Reads the manifest of the package in `packageDir`: its
+ * syncbridge-manifest.json, or else the `syncbridge` field of its
+ * package.json. Undefined when it has neither: it is not an extension
+ * package. Throws when it has both, as which one counts would be unclear.
+ */
+export declare function readExtensionManifest(packageDir: string, pkgJson?: ExtensionPackageJson): ReadManifest | undefined;
+/**
+ * The manifest of the package in `packageDir`, when it is an extension
+ * package (see readExtensionManifest)
+ */
+export declare function manifestOf(packageDir: string, pkgJson?: ExtensionPackageJson): SyncBridgeManifest | undefined;

package/registry/package-manifest.js

@@ -1,2 +1,59 @@
-export {};
-//# sourceMappingURL=package-manifest.js.map
+import fs from 'node:fs';
+import path from 'node:path';
+import { SbError } from '../classes/sb-error.js';
+/** The file an extension package's manifest is in, at its root */
+export const MANIFEST_FILE = 'syncbridge-manifest.json';
+/** The fields of a manifest SyncBridge knows */
+const KNOWN_FIELDS = new Set([
+    'name',
+    'dependencies',
+    'apps',
+    'components',
+    'plugins',
+    'docsLanguage',
+]);
+/**
+ * Reads the manifest of the package in `packageDir`: its
+ * syncbridge-manifest.json, or else the `syncbridge` field of its
+ * package.json. Undefined when it has neither: it is not an extension
+ * package. Throws when it has both, as which one counts would be unclear.
+ */
+export function readExtensionManifest(packageDir, pkgJson) {
+    pkgJson =
+        pkgJson ||
+            (fs.existsSync(path.join(packageDir, 'package.json'))
+                ? JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'))
+                : undefined);
+    const file = path.join(packageDir, MANIFEST_FILE);
+    const inFile = fs.existsSync(file);
+    const inPackageJson = pkgJson?.syncbridge != null;
+    if (inFile && inPackageJson)
+        throw new SbError(`"${pkgJson.name}" has a manifest both in ${MANIFEST_FILE} and in the "syncbridge" field of package.json: keep one`);
+    let manifest;
+    if (inFile) {
+        try {
+            manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch (e) {
+            throw new SbError(`${file} is not valid JSON: ${e.message}`);
+        }
+    }
+    else if (inPackageJson)
+        manifest = pkgJson.syncbridge;
+    else
+        return;
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest))
+        throw new SbError(`The manifest of "${pkgJson?.name || packageDir}" must be an object`);
+    return {
+        manifest,
+        source: inFile ? 'file' : 'package.json',
+        unknownFields: Object.keys(manifest).filter(k => !KNOWN_FIELDS.has(k)),
+    };
+}
+/**
+ * The manifest of the package in `packageDir`, when it is an extension
+ * package (see readExtensionManifest)
+ */
+export function manifestOf(packageDir, pkgJson) {
+    return readExtensionManifest(packageDir, pkgJson)?.manifest;
+}

package/utils/decode-profile.d.ts

@@ -1,5 +1,5 @@
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ProcessorMetadata, Profile } from '../models/index.js';
+import { AppMetadata, Profile, VariableMetadataRecord } from '../models/index.js';
 export interface CodecOptions {
     setDefaultValues?: boolean;
     cryptoSecretKey?: string;
@@ -11,7 +11,7 @@ export declare function decodeProfile(profile: Profile, options?: CodecOptions):
 export declare function decodeProfileSilent(profile: Profile, options?: CodecOptions): {
     result: true;
     profile: Profile;
-    metadata: ProcessorMetadata;
+    metadata: AppMetadata;
     issues?: StackExecutor.Issue[];
 } | {
     result: false;
@@ -32,3 +32,19 @@ export declare function encodeProfileSilent(profile: Profile, options?: CodecOpt
     result: false;
     issues: StackExecutor.Issue[];
 };
+/**
+ * Decodes values by the variables that define them - checks each against
+ * its type and rules and sets the defaults - as a profile's values are.
+ * Values no variable defines are left out. Issues are located by the
+ * values' keys, below `location` when one is given.
+ */
+export declare function decodeValues(variables: VariableMetadataRecord, values: Record<string, any> | undefined, options?: CodecOptions & {
+    location?: string;
+}): {
+    result: true;
+    values: Record<string, any>;
+    issues: StackExecutor.Issue[];
+} | {
+    result: false;
+    issues: StackExecutor.Issue[];
+};

package/utils/decode-profile.js

@@ -1,7 +1,7 @@
 import { isAny, isBase64, isBigint, isBoolean, isDateString, isEmail, isHex, isNumber, isString, isTime, isURL, validator, vg, } from 'valgen';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ElementComponentMetadata, ProcessorMetadata, Profile, ProfileComponent, VariableMetadataRecord, VariableType, } from '../models/index.js';
+import { AppMetadata, ElementComponentMetadata, Profile, ProfileComponent, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { getModelsDocument } from '../models-document.js';
 import { secretDecryptor, secretEncryptor } from './encrypt-helpers.js';
 import { materializeMetadataSilent } from './materialize-metadata.js';
@@ -81,7 +81,7 @@ export function encodeProfileSilent(profile, options) {
     const fn = t.generateCodec('encode', { coerce: true });
     const out = fn({
         id: profile.id,
-        processorUri: profile.processorUri,
+        appUri: profile.appUri,
         displayName: profile.displayName,
         group: profile.group,
         description: profile.description,
@@ -106,6 +106,8 @@ export function encodeProfileSilent(profile, options) {
  * @private
  */
 function _codecProcessElement(stackExecutor, codec, metadata, profile, options) {
+    if (codec === 'decode')
+        _checkLogChannels(stackExecutor, metadata, profile);
     profile.values = profile.values || {};
     if (metadata.variables) {
         stackExecutor.execute('values', () => {
@@ -134,18 +136,67 @@ function _codecProcessElement(stackExecutor, codec, metadata, profile, options)
         delete profile?.components;
 }
 /**
- *
- * @protected
+ * Warns of an element's log channel settings that name what it does not
+ * have: a channel, or an event its channel does not write. Warnings only:
+ * a package's next version may drop either, and a worker does not stop
+ * for a log setting.
+ */
+function _checkLogChannels(stackExecutor, metadata, profile) {
+    const settings = profile.settings?.logs?.channels;
+    if (!settings)
+        return;
+    const at = stackExecutor.stack.join('/');
+    const warn = (location, message) => stackExecutor.issues.push({
+        message,
+        severity: 'warning',
+        location: (at ? at + '/' : '') + location,
+    });
+    for (const [name, channelSettings] of Object.entries(settings)) {
+        const where = `settings/logs/channels/${name}`;
+        const definition = metadata.logChannels?.[name];
+        if (!definition) {
+            /* The app's settings keep the worker's console, defined by none */
+            if (!(name === 'console' && !at))
+                warn(where, `"${name}" is not a log channel of this element`);
+            continue;
+        }
+        const unknown = (channelSettings?.events || []).filter(event => !definition.events?.includes(event));
+        if (unknown.length)
+            warn(`${where}/events`, `${unknown.map(e => `"${e}"`).join(', ')} ${unknown.length === 1 ? 'is not an event' : 'are not events'} of the "${name}" channel. It has: ${definition.events?.join(', ') || 'none'}`);
+    }
+}
+/**
+ * Decodes values by the variables that define them - checks each against
+ * its type and rules and sets the defaults - as a profile's values are.
+ * Values no variable defines are left out. Issues are located by the
+ * values' keys, below `location` when one is given.
  */
+export function decodeValues(variables, values, options) {
+    const stackExecutor = new StackExecutor();
+    let out = {};
+    const run = () => {
+        out = _codecValues(stackExecutor, 'decode', variables, values, options);
+    };
+    if (options?.location)
+        stackExecutor.execute(options.location, run);
+    else
+        run();
+    if (stackExecutor.issues.find(i => !(i.severity === 'warning' || i.severity === 'info')))
+        return { result: false, issues: stackExecutor.issues };
+    return { result: true, values: out, issues: stackExecutor.issues };
+}
 function _decodeVariables(stackExecutor, codec, metadata, profile, options) {
     if (!metadata.variables) {
         delete profile.values;
         return;
     }
-    const oldValues = profile.values;
-    profile.values = {};
-    const process = (variables, target, oldVals) => {
-        for (const [k, defVariable] of Object.entries(variables)) {
+    profile.values = _codecValues(stackExecutor, codec, metadata.variables, profile.values, options);
+}
+/** The values the variables define, decoded or encoded */
+function _codecValues(stackExecutor, codec, variables, oldValues, options) {
+    const values = {};
+    const process = (defs, target, oldVals) => {
+        for (const [k, defVariable] of Object.entries(defs)) {
             stackExecutor.execute(k, () => {
                 if (defVariable == null)
                     return;
@@ -280,6 +331,10 @@ function _decodeVariables(stackExecutor, codec, metadata, profile, options) {
                             valueFn = vg.pipe([valueFn, ...fns]);
                     }
                 }
+                /* A required value that is missing is told as such, not as a value
+                 * of the wrong type */
+                if (defVariable.required && !hasDefault && codec === 'decode')
+                    valueFn = vg.required(valueFn);
                 if (!defVariable.required && !hasDefault) {
                     valueFn = defVariable.nullable
                         ? vg.nullable(valueFn)
@@ -289,6 +344,6 @@ function _decodeVariables(stackExecutor, codec, metadata, profile, options) {
             });
         }
     };
-    process(metadata.variables, profile.values, oldValues);
+    process(variables, values, oldValues);
+    return values;
 }
-//# sourceMappingURL=decode-profile.js.map

package/utils/encrypt-helpers.d.ts

@@ -1,2 +1,9 @@
+/** What marks a value encrypted, before its text */
+export declare const SECRET_PREFIX = "sbscrt::";
+/**
+ * A secret value kept encrypted: one already so, encrypted anew (a fresh
+ * salt and IV) - its text, not its prefix, taken as encrypted
+ */
 export declare const secretEncryptor: (secretKey: string) => import("valgen").Validator<string, string, import("valgen").ExecutionOptions>;
+/** A secret value read: one encrypted, its text; any other, as it is */
 export declare const secretDecryptor: (secretKey: string) => import("valgen").Validator<string, string, import("valgen").ExecutionOptions>;

package/utils/encrypt-helpers.js

@@ -1,17 +1,24 @@
 import crypto from 'node:crypto';
 import { validator } from 'valgen';
+/** What marks a value encrypted, before its text */
+export const SECRET_PREFIX = 'sbscrt::';
+/**
+ * A secret value kept encrypted: one already so, encrypted anew (a fresh
+ * salt and IV) - its text, not its prefix, taken as encrypted
+ */
 export const secretEncryptor = (secretKey) => {
     return validator((input) => {
-        if (input.startsWith('sbscrt::')) {
-            input = decryptText(input, secretKey);
+        if (input.startsWith(SECRET_PREFIX)) {
+            input = decryptText(input.substring(SECRET_PREFIX.length), secretKey);
         }
-        return 'sbscrt::' + encryptText(input, secretKey);
+        return SECRET_PREFIX + encryptText(input, secretKey);
     });
 };
+/** A secret value read: one encrypted, its text; any other, as it is */
 export const secretDecryptor = (secretKey) => {
     return validator((input) => {
-        if (input.startsWith('sbscrt::')) {
-            return decryptText(input.substring(6), secretKey);
+        if (input.startsWith(SECRET_PREFIX)) {
+            return decryptText(input.substring(SECRET_PREFIX.length), secretKey);
         }
         return input;
     });
@@ -41,4 +48,3 @@ function decryptText(input, secretKey) {
     ]);
     return decrypted.toString('utf8');
 }
-//# sourceMappingURL=encrypt-helpers.js.map

package/utils/locate-package-json.js

@@ -22,4 +22,3 @@ export function resolvePackageJson(directory) {
     const content = fs.readFileSync(path.resolve(pkg, 'package.json'), 'utf-8');
     return JSON.parse(content);
 }
-//# sourceMappingURL=locate-package-json.js.map

package/utils/materialize-metadata.d.ts

@@ -1,12 +1,12 @@
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ProcessorMetadata, Profile } from '../models/index.js';
+import { AppMetadata, Profile } from '../models/index.js';
 /**
  * Materializes metadata from profile.
  */
 export declare function materializeMetadata(profile: Profile, options?: {
     returnUndefinedComponentsAsAbstract?: boolean;
     removeIgnoredVariables?: boolean;
-}): ProcessorMetadata;
+}): AppMetadata;
 /**
  *
  */
@@ -15,7 +15,7 @@ export declare function materializeMetadataSilent(profile: Profile, options?: {
     removeIgnoredVariables?: boolean;
 }): {
     result: true;
-    metadata: ProcessorMetadata;
+    metadata: AppMetadata;
     issues: StackExecutor.Issue[];
 } | {
     result: false;

package/utils/materialize-metadata.js

@@ -1,7 +1,7 @@
 import { clone, merge, omit, omitUndefined } from '@jsopen/objects';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ElementComponentMetadata, ElementComponentMetadataRecord, ProcessorMetadata, Profile, ProfileComponent, VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
+import { AppMetadata, ElementComponentMetadata, ElementComponentMetadataRecord, Profile, ProfileComponent, VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
 /**
  * Materializes metadata from profile.
@@ -29,18 +29,18 @@ export function materializeMetadata(profile, options) {
  */
 export function materializeMetadataSilent(profile, options) {
     const stackExecutor = new StackExecutor();
-    const processorRec = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
+    const appRec = ExtensionRegistry.getApp(profile.appUri, profile.appVersion);
     const metadata = omitUndefined(clone({
-        classType: processorRec.metadata.classType,
-        className: processorRec.metadata.className,
-        version: processorRec.version,
-        displayName: processorRec.metadata.displayName,
-        description: processorRec.metadata.description,
-        iconUrl: processorRec.metadata.iconUrl,
-        tags: processorRec.metadata.tags,
-        variables: processorRec.metadata.variables,
-        components: processorRec.metadata.components,
-        ...processorRec.metadata,
+        classType: appRec.metadata.classType,
+        className: appRec.metadata.className,
+        version: appRec.version,
+        displayName: appRec.metadata.displayName,
+        description: appRec.metadata.description,
+        iconUrl: appRec.metadata.iconUrl,
+        tags: appRec.metadata.tags,
+        variables: appRec.metadata.variables,
+        components: appRec.metadata.components,
+        ...appRec.metadata,
     }, { deep: 'full' }));
     if (metadata.variables) {
         /* Remove ignored variables */
@@ -101,6 +101,10 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, options) {
                 };
                 materializedComponent.variables = merge({}, [reg.metadata.variables || {}, metadataComponent.variables || {}], { deep: 'full' });
                 materializedComponent.variables = sortVariables(materializedComponent.variables);
+                if (reg.metadata.logChannels)
+                    materializedComponent.logChannels = clone(reg.metadata.logChannels, {
+                        deep: 'full',
+                    });
                 out[componentName] = materializedComponent;
                 /** Remove ignored variables */
                 for (const [k, variable] of Object.entries(materializedComponent.variables)) {
@@ -142,4 +146,3 @@ function sortVariables(variables) {
         return a;
     }, {});
 }
-//# sourceMappingURL=materialize-metadata.js.map

package/utils/normalize-metadata.d.ts

@@ -1,8 +1,10 @@
+import 'reflect-metadata';
+import type { Type } from 'ts-gems';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
-export declare function normalizeProcessorMetadata(metadata: ProcessorMetadata): Promise<ProcessorMetadata>;
-export declare function normalizeProcessorMetadataSilent(metadata: ProcessorMetadata): Promise<{
-    metadata: ProcessorMetadata;
+import { AppMetadata, ComponentMetadata, PluginMetadata, VariableMetadataRecord } from '../models/index.js';
+export declare function normalizeAppMetadata(metadata: AppMetadata): Promise<AppMetadata>;
+export declare function normalizeAppMetadataSilent(metadata: AppMetadata): Promise<{
+    metadata: AppMetadata;
     issues?: StackExecutor.Issue[];
 }>;
 export declare function normalizeComponentMetadata(metadata: ComponentMetadata): Promise<ComponentMetadata>;
@@ -10,3 +12,20 @@ export declare function normalizeComponentMetadataSilent(metadata: ComponentMeta
     metadata: ComponentMetadata;
     issues?: StackExecutor.Issue[];
 }>;
+/**
+ * A plugin's definition checked and given its defaults; throws an
+ * SbValidationError listing what is wrong
+ */
+export declare function normalizePluginMetadata(metadata: PluginMetadata): Promise<PluginMetadata>;
+/**
+ * The variables a class defines with @DefineVariable, as they are now: read
+ * them when the class is defined, as metadata read later may be gone if
+ * another copy of reflect-metadata took over the global Reflect since.
+ * Undefined when the class defines none.
+ */
+export declare function readVariables(variablesClass: Type): VariableMetadataRecord | undefined;
+/**
+ * Variables as the metadata of an element holds them: what they are given
+ * as promises resolved, enum values as arrays
+ */
+export declare function normalizeVariablesMetadata(variables: VariableMetadataRecord): Promise<VariableMetadataRecord>;

package/utils/normalize-metadata.js

@@ -1,11 +1,13 @@
+import 'reflect-metadata';
 import { deepClone, merge } from '@jsopen/objects';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ComponentMetadata, ElementComponentMetadataRecord, ProcessorMetadata, VariableMetadataRecord, } from '../models/index.js';
+import { VARIABLE_CONTAINER } from '../constants.js';
+import { AppMetadata, ComponentMetadata, ElementComponentMetadataRecord, PluginMetadata, VariableMetadataRecord, } from '../models/index.js';
 import { initializeModelsDocument } from '../models-document.js';
 import { resolvePromisesDeep } from './resolve-promises.js';
-export async function normalizeProcessorMetadata(metadata) {
-    const { metadata: out, issues } = await normalizeProcessorMetadataSilent(metadata);
+export async function normalizeAppMetadata(metadata) {
+    const { metadata: out, issues } = await normalizeAppMetadataSilent(metadata);
     if (issues?.length) {
         const msg = 'Worker profile decoding error.\n  ' +
             issues
@@ -21,10 +23,10 @@ export async function normalizeProcessorMetadata(metadata) {
     }
     return out;
 }
-export async function normalizeProcessorMetadataSilent(metadata) {
+export async function normalizeAppMetadataSilent(metadata) {
     const decoder = await getProcMetadataTypeDecoder();
     let cloned = deepClone({
-        classType: 'processor',
+        classType: 'app',
         className: metadata.className,
         displayName: metadata.displayName,
         description: metadata.description,
@@ -99,6 +101,32 @@ export async function normalizeComponentMetadataSilent(metadata) {
         })),
     };
 }
+/**
+ * A plugin's definition checked and given its defaults; throws an
+ * SbValidationError listing what is wrong
+ */
+export async function normalizePluginMetadata(metadata) {
+    if (!_pluginMetadataTypeDecoder) {
+        const apiDoc = await initializeModelsDocument();
+        _pluginMetadataTypeDecoder = apiDoc.node
+            .getComplexType(PluginMetadata)
+            .generateCodec('decode', { coerce: true });
+    }
+    const cloned = await resolvePromisesDeep(deepClone({ ...metadata, classType: 'plugin' }));
+    cloned.settings = normalizeVariables(cloned.settings);
+    const { value, errors } = _pluginMetadataTypeDecoder.silent(cloned);
+    if (!errors?.length)
+        return value;
+    throw new SbValidationError('Invalid plugin definition.\n  ' +
+        errors.map(e => `- ${e.message}. Location: /${e.location}`).join('\n  '), {
+        issues: errors.map(e => ({
+            message: e.message,
+            severity: 'error',
+            location: e.location,
+            code: 'validation-error:' + e.rule,
+        })),
+    });
+}
 function normalizeComponents(components) {
     if (!components)
         return;
@@ -110,6 +138,23 @@ function normalizeComponents(components) {
     }
     return components;
 }
+/**
+ * The variables a class defines with @DefineVariable, as they are now: read
+ * them when the class is defined, as metadata read later may be gone if
+ * another copy of reflect-metadata took over the global Reflect since.
+ * Undefined when the class defines none.
+ */
+export function readVariables(variablesClass) {
+    const variables = Reflect.getMetadata(VARIABLE_CONTAINER, variablesClass.prototype);
+    return variables ? deepClone(variables) : undefined;
+}
+/**
+ * Variables as the metadata of an element holds them: what they are given
+ * as promises resolved, enum values as arrays
+ */
+export async function normalizeVariablesMetadata(variables) {
+    return normalizeVariables(await resolvePromisesDeep(deepClone(variables)));
+}
 function normalizeVariables(variables) {
     if (!variables)
         return;
@@ -134,6 +179,7 @@ function normalizeVariables(variables) {
 // ************************************************************************
 let _compMetadataTypeDecoder;
 let _procMetadataTypeDecoder;
+let _pluginMetadataTypeDecoder;
 async function getCompMetadataTypeDecoder() {
     if (!_compMetadataTypeDecoder) {
         const apiDoc = await initializeModelsDocument();
@@ -147,11 +193,10 @@ async function getCompMetadataTypeDecoder() {
 async function getProcMetadataTypeDecoder() {
     if (!_procMetadataTypeDecoder) {
         const apiDoc = await initializeModelsDocument();
-        const procMetadataType = apiDoc.node.getComplexType(ProcessorMetadata);
+        const procMetadataType = apiDoc.node.getComplexType(AppMetadata);
         _procMetadataTypeDecoder = procMetadataType.generateCodec('decode', {
             coerce: true,
         });
     }
     return _procMetadataTypeDecoder;
 }
-//# sourceMappingURL=normalize-metadata.js.map

package/utils/registry-names.js

@@ -106,4 +106,3 @@ export function parseSbSpecifier(specifier) {
     assertRegistryName(m[1]);
     return { name: m[1], subpath: m[2] ? '.' + m[2] : '.' };
 }
-//# sourceMappingURL=registry-names.js.map

package/utils/resolve-promises.js

@@ -8,4 +8,3 @@ export async function resolvePromisesDeep(obj) {
     }
     return obj;
 }
-//# sourceMappingURL=resolve-promises.js.map

package/utils/type-guards.d.ts

@@ -1,6 +1,6 @@
+import { AppBase } from '../classes/app-base.js';
 import { ComponentBase } from '../classes/component-base.js';
-import { ProcessorBase } from '../classes/processor-base.js';
 import { Runnable } from '../classes/runnable.js';
 export declare function isRunnable(proto: any): proto is Runnable;
-export declare function isProcessorBase(proto: any): proto is ProcessorBase;
+export declare function isAppBase(proto: any): proto is AppBase;
 export declare function isComponentBase(proto: any): proto is ComponentBase;

package/utils/type-guards.js

@@ -1,16 +1,15 @@
+import { AppBase } from '../classes/app-base.js';
 import { ComponentBase } from '../classes/component-base.js';
-import { ProcessorBase } from '../classes/processor-base.js';
 import { Runnable } from '../classes/runnable.js';
 const RUNNABLE_TOKEN = Symbol.for(Runnable.name);
-const PROCESSOR_BASE_TOKEN = Symbol.for(ProcessorBase.name);
+const APP_BASE_TOKEN = Symbol.for(AppBase.name);
 const COMPONENT_BASE_TOKEN = Symbol.for(ComponentBase.name);
 export function isRunnable(proto) {
     return !!proto[RUNNABLE_TOKEN];
 }
-export function isProcessorBase(proto) {
-    return !!proto[PROCESSOR_BASE_TOKEN];
+export function isAppBase(proto) {
+    return !!proto[APP_BASE_TOKEN];
 }
 export function isComponentBase(proto) {
     return !!proto[COMPONENT_BASE_TOKEN];
 }
-//# sourceMappingURL=type-guards.js.map

package/utils/uri-to-id.js

@@ -5,4 +5,3 @@ export function uriToId(uri) {
         .replace(/\W/g, '_')
         .toLowerCase();
 }
-//# sourceMappingURL=uri-to-id.js.map

package/utils/worker-permissions.d.ts

@@ -0,0 +1,25 @@
+import { WorkerPermission } from '../models/enums/worker-permission.enum.js';
+import type { AppMetadata } from '../models/metadata/app-metadata.js';
+import type { ComponentMetadata } from '../models/metadata/component-metadata.js';
+/**
+ * What of the server a worker reaches: as its app declares, and each
+ * component it is given - the one its profile chose, else the one its app
+ * asks for - and theirs, all the way down
+ */
+export declare function workerPermissionsOf(metadata: AppMetadata | undefined, find: (uri: string) => ComponentMetadata | undefined): WorkerPermission[];
+/**
+ * Node's permission model for a worker: it reads and writes the paths
+ * told (any, when none), and reaches native addons and other programs as
+ * it declares them (native-code, child-processes) - both outside the
+ * model; worker threads never, outside it too
+ */
+export declare function nodePermissionArgs(args: {
+    read?: string[];
+    write?: string[];
+    permissions: string[];
+}): string[];
+/**
+ * What a worker refused by the permission model is to declare, from the
+ * error it failed with: none, it was not refused so
+ */
+export declare function missingPermissionOf(message: string): WorkerPermission | undefined;