@swiftbrowser/cli 0.1.0 → 0.2.0

package/dist/coreml.js

@@ -0,0 +1,626 @@
+// Core ML models, compiled the way Xcode compiles them: a `.mlmodel` in the
+// target's Sources becomes a Swift class (`SleepCalculator`, with its
+// `SleepCalculatorInput` and `SleepCalculatorOutput`) the app calls. Xcode
+// also compiles the model to an `.mlmodelc` the class loads at run time; here
+// the model is read from its protobuf (Model.proto in apple/coremltools),
+// checked against what the shim's CoreML module can evaluate, and embedded in
+// the generated class as a JSON description of its math (docs/ops-protocol.md,
+// "Core ML models").
+//
+// Supported: what Create ML's tabular regressors and classifiers are made of.
+// Linear and logistic models (GLM), boosted trees and random forests (tree
+// ensembles), and pipelines of them with feature vectorizers, one-hot
+// encoders, imputers, normalizers, scalers, dictionary vectorizers, array
+// feature extractors, categorical mappings and identities. Anything else
+// (neural networks, ML programs, Vision and Natural Language models) is a
+// CliError naming the model type.
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { CliError } from './log.js';
+import { ProtobufError, decodeMessage } from './protobuf.js';
+// --- Reading Model.proto ---
+/** Model.proto's `oneof Type`: field number → name, for the supported types and for naming the others. */
+const MODEL_TYPES = {
+    200: 'pipelineClassifier',
+    201: 'pipelineRegressor',
+    202: 'pipeline',
+    300: 'glmRegressor',
+    301: 'supportVectorRegressor',
+    302: 'treeEnsembleRegressor',
+    303: 'neuralNetworkRegressor',
+    304: 'bayesianProbitRegressor',
+    400: 'glmClassifier',
+    401: 'supportVectorClassifier',
+    402: 'treeEnsembleClassifier',
+    403: 'neuralNetworkClassifier',
+    404: 'kNearestNeighborsClassifier',
+    500: 'neuralNetwork',
+    501: 'itemSimilarityRecommender',
+    502: 'mlProgram',
+    555: 'customModel',
+    556: 'linkedModel',
+    560: 'classConfidenceThresholding',
+    600: 'oneHotEncoder',
+    601: 'imputer',
+    602: 'featureVectorizer',
+    603: 'dictVectorizer',
+    604: 'scaler',
+    606: 'categoricalMapping',
+    607: 'normalizer',
+    609: 'arrayFeatureExtractor',
+    610: 'nonMaximumSuppression',
+    900: 'identity',
+    2000: 'textClassifier',
+    2001: 'wordTagger',
+    2002: 'visionFeaturePrint',
+    2003: 'soundAnalysisPreprocessing',
+    2004: 'gazetteer',
+    2005: 'wordEmbedding',
+    2006: 'audioFeaturePrint',
+    3000: 'serializedModel',
+};
+/** What the unsupported types are, in words, for the error message. */
+const UNSUPPORTED_TYPES = {
+    supportVectorRegressor: 'a support vector machine regressor',
+    supportVectorClassifier: 'a support vector machine classifier',
+    neuralNetworkRegressor: 'a neural network regressor',
+    neuralNetworkClassifier: 'a neural network classifier',
+    neuralNetwork: 'a neural network',
+    bayesianProbitRegressor: 'a Bayesian probit regressor',
+    kNearestNeighborsClassifier: 'a k-nearest neighbors classifier',
+    itemSimilarityRecommender: 'a recommender',
+    mlProgram: 'an ML program (a converted neural network)',
+    customModel: 'a custom model',
+    linkedModel: 'a linked model',
+    classConfidenceThresholding: 'a class confidence thresholding model',
+    nonMaximumSuppression: 'a non-maximum suppression model (object detection)',
+    textClassifier: 'a Natural Language text classifier',
+    wordTagger: 'a Natural Language word tagger',
+    visionFeaturePrint: 'a Vision feature print (image models)',
+    soundAnalysisPreprocessing: 'a sound analysis model',
+    gazetteer: 'a Natural Language gazetteer',
+    wordEmbedding: 'a Natural Language word embedding',
+    audioFeaturePrint: 'an audio feature print',
+    serializedModel: 'a serialized model',
+};
+export const SUPPORTED_SUMMARY = 'linear and logistic regression (GLM), boosted trees and random forests (tree ensembles), and pipelines of them with feature vectorizers, one-hot encoders, imputers, normalizers, scalers and the other feature-engineering models';
+/** A model the CLI cannot compile: names the file and what is wrong. */
+export class ModelError extends CliError {
+}
+class Reader {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    fail(message) {
+        throw new ModelError(`${path.basename(this.file)}: ${message}`);
+    }
+    model(message, where) {
+        const specificationVersion = message.int(1);
+        const descriptionMessage = message.message(2);
+        if (!descriptionMessage)
+            this.fail(`${where} has no description`);
+        const description = this.description(descriptionMessage, where);
+        const typeFields = message.numbers().filter((n) => n >= 200);
+        if (typeFields.length === 0)
+            this.fail(`${where} has no model type`);
+        const number = typeFields[0];
+        const typeName = MODEL_TYPES[number] ?? `type ${number}`;
+        const body = message.message(number) ?? decodeMessage(new Uint8Array());
+        return { specificationVersion, description, model: this.kind(typeName, body, where, description) };
+    }
+    description(message, where) {
+        if (message.has(20) && !message.has(1))
+            this.fail(`${where} declares several functions (a multifunction model), which is not supported`);
+        const description = {
+            inputs: message.messages(1).map((feature) => this.feature(feature, where)),
+            outputs: message.messages(10).map((feature) => this.feature(feature, where)),
+        };
+        const predicted = message.string(11);
+        if (predicted)
+            description.predictedFeatureName = predicted;
+        const probabilities = message.string(12);
+        if (probabilities)
+            description.predictedProbabilitiesName = probabilities;
+        const metadataMessage = message.message(100);
+        if (metadataMessage) {
+            const metadata = {};
+            const fields = [['shortDescription', 1], ['versionString', 2], ['author', 3], ['license', 4]];
+            for (const [key, number] of fields) {
+                const value = metadataMessage.string(number);
+                if (value)
+                    metadata[key] = value;
+            }
+            const userDefined = metadataMessage.messages(100);
+            if (userDefined.length > 0)
+                metadata.creatorDefined = Object.fromEntries(userDefined.map((entry) => [entry.string(1), entry.string(2)]));
+            if (Object.keys(metadata).length > 0)
+                description.metadata = metadata;
+        }
+        return description;
+    }
+    feature(message, where) {
+        const name = message.string(1);
+        const typeMessage = message.message(3);
+        if (!typeMessage)
+            this.fail(`feature "${name}" of ${where} has no type`);
+        const type = this.featureType(typeMessage, `feature "${name}" of ${where}`);
+        const feature = { name, ...type };
+        if (typeMessage.bool(1000))
+            feature.optional = true;
+        const shortDescription = message.string(2);
+        if (shortDescription)
+            feature.shortDescription = shortDescription;
+        return feature;
+    }
+    featureType(message, what) {
+        if (message.has(1))
+            return { type: 'int64' };
+        if (message.has(2))
+            return { type: 'double' };
+        if (message.has(3))
+            return { type: 'string' };
+        if (message.has(5)) {
+            const array = message.message(5);
+            const dataTypes = { 65600: 'double', 65568: 'float32', 65552: 'float16', 131104: 'int32', 131080: 'int8' };
+            const dataType = dataTypes[array.int(2)] ?? 'double';
+            return { type: 'multiArray', shape: array.ints(1), dataType };
+        }
+        if (message.has(6)) {
+            const dictionary = message.message(6);
+            return { type: 'dictionary', keyType: dictionary.has(1) ? 'int64' : 'string' };
+        }
+        const kinds = { 4: 'an image', 7: 'a sequence', 8: 'a state' };
+        const kind = message.numbers().map((n) => kinds[n]).find((k) => k !== undefined);
+        this.fail(`${what} is ${kind ?? 'of an unknown type'}, which is not supported (Int64, Double, String, MLMultiArray and dictionaries are)`);
+    }
+    labels(message, what) {
+        if (message.has(100))
+            return { strings: message.message(100).strings(1) };
+        if (message.has(101))
+            return { int64s: message.message(101).ints(1) };
+        this.fail(`${what} has no class labels`);
+    }
+    kind(typeName, body, where, description) {
+        switch (typeName) {
+            case 'pipeline':
+                return { kind: 'pipeline', models: this.pipeline(body, where) };
+            case 'pipelineClassifier':
+            case 'pipelineRegressor':
+                return { kind: typeName, models: this.pipeline(body.message(1) ?? decodeMessage(new Uint8Array()), where) };
+            case 'glmRegressor': {
+                const transforms = ['none', 'logit', 'probit'];
+                const weights = body.messages(1).map((row) => row.doubles(1));
+                const offsets = body.doubles(2);
+                this.checkGLM(weights, offsets, where);
+                return { kind: 'glmRegressor', weights, offsets, transform: transforms[body.int(3)] ?? this.fail(`${where}: unknown GLM transform ${body.int(3)}`) };
+            }
+            case 'glmClassifier': {
+                const transforms = ['logit', 'probit'];
+                const encodings = ['referenceClass', 'oneVsRest'];
+                const weights = body.messages(1).map((row) => row.doubles(1));
+                const offsets = body.doubles(2);
+                this.checkGLM(weights, offsets, where);
+                const labels = this.labels(body, where);
+                const encoding = encodings[body.int(4)] ?? this.fail(`${where}: unknown class encoding ${body.int(4)}`);
+                const classes = labelCount(labels);
+                const rows = weights.length;
+                // One row is binary (the second label's probability); otherwise one row
+                // per class (one vs. rest) or per class but the first (reference class).
+                if (!(rows === 1 && classes === 2) && !(encoding === 'oneVsRest' && rows === classes) && !(encoding === 'referenceClass' && rows === classes - 1)) {
+                    this.fail(`${where}: a GLM classifier with ${rows} weight rows for ${classes} classes (${encoding}) is not supported`);
+                }
+                return { kind: 'glmClassifier', weights, offsets, transform: transforms[body.int(3)] ?? this.fail(`${where}: unknown GLM transform ${body.int(3)}`), encoding, labels };
+            }
+            case 'treeEnsembleRegressor':
+                return { kind: 'treeEnsembleRegressor', ...this.treeEnsemble(body, where) };
+            case 'treeEnsembleClassifier': {
+                const ensemble = this.treeEnsemble(body, where);
+                const labels = this.labels(body, where);
+                const classes = labelCount(labels);
+                const d = ensemble.dimensions;
+                const fits = ensemble.transform === 'softmaxWithZeroClassReference' ? d === classes - 1 : d === classes || (d === 1 && classes === 2);
+                if (!fits)
+                    this.fail(`${where}: a tree ensemble classifier with ${d} prediction dimensions for ${classes} classes (${ensemble.transform}) is not supported`);
+                return { kind: 'treeEnsembleClassifier', ...ensemble, labels };
+            }
+            case 'featureVectorizer':
+                return { kind: 'featureVectorizer', columns: body.messages(1).map((column) => ({ name: column.string(1), dimensions: column.int(2) })) };
+            case 'oneHotEncoder': {
+                let categories;
+                if (body.has(1))
+                    categories = { strings: body.message(1).strings(1) };
+                else if (body.has(2))
+                    categories = { int64s: body.message(2).ints(1) };
+                else
+                    this.fail(`${where}: a one-hot encoder without categories`);
+                return { kind: 'oneHotEncoder', categories, sparse: body.bool(10), ignoreUnknown: body.int(11) === 1 };
+            }
+            case 'normalizer': {
+                const norms = ['max', 'l1', 'l2'];
+                return { kind: 'normalizer', norm: norms[body.int(1)] ?? this.fail(`${where}: unknown norm ${body.int(1)}`) };
+            }
+            case 'imputer':
+                return this.imputer(body, where);
+            case 'scaler':
+                return { kind: 'scaler', shift: body.doubles(1), scale: body.doubles(2) };
+            case 'dictVectorizer': {
+                if (body.has(1))
+                    return { kind: 'dictVectorizer', keys: { strings: body.message(1).strings(1) } };
+                if (body.has(2))
+                    return { kind: 'dictVectorizer', keys: { int64s: body.message(2).ints(1) } };
+                return this.fail(`${where}: a dictionary vectorizer without keys`);
+            }
+            case 'arrayFeatureExtractor':
+                return { kind: 'arrayFeatureExtractor', indices: body.ints(1) };
+            case 'categoricalMapping': {
+                const mapping = { kind: 'categoricalMapping' };
+                if (body.has(1))
+                    mapping.stringToInt64 = Object.fromEntries(body.message(1).messages(1).map((entry) => [entry.string(1), entry.int(2)]));
+                else if (body.has(2))
+                    mapping.int64ToString = Object.fromEntries(body.message(2).messages(1).map((entry) => [String(entry.int(1)), entry.string(2)]));
+                else
+                    this.fail(`${where}: a categorical mapping without a map`);
+                if (body.has(101))
+                    mapping.defaultString = body.string(101);
+                if (body.has(102))
+                    mapping.defaultInt64 = body.int(102);
+                return mapping;
+            }
+            case 'identity':
+                if (description.inputs.length !== description.outputs.length)
+                    this.fail(`${where}: an identity model needs as many outputs as inputs`);
+                return { kind: 'identity' };
+            default: {
+                const what = UNSUPPORTED_TYPES[typeName];
+                this.fail(`${where} is ${what ? `${what} (${typeName})` : `a model of type ${typeName}`}, which the browser cannot run. Supported: ${SUPPORTED_SUMMARY}`);
+            }
+        }
+    }
+    pipeline(message, where) {
+        const models = message.messages(1);
+        if (models.length === 0)
+            this.fail(`${where} is an empty pipeline`);
+        return models.map((model, index) => this.model(model, `${where === 'the model' ? 'pipeline' : where} step ${index + 1}`));
+    }
+    checkGLM(weights, offsets, where) {
+        if (weights.length === 0)
+            this.fail(`${where}: a GLM without weights`);
+        if (offsets.length !== 0 && offsets.length !== weights.length)
+            this.fail(`${where}: ${weights.length} weight rows but ${offsets.length} offsets`);
+    }
+    treeEnsemble(body, where) {
+        const parameters = body.message(1);
+        if (!parameters)
+            this.fail(`${where}: a tree ensemble without parameters`);
+        const transforms = ['none', 'softmax', 'logistic', 'softmaxWithZeroClassReference'];
+        const transform = transforms[body.int(2)] ?? this.fail(`${where}: unknown tree ensemble transform ${body.int(2)}`);
+        const dimensions = Math.max(1, parameters.int(2));
+        const base = parameters.doubles(3);
+        if (base.length !== 0 && base.length !== dimensions)
+            this.fail(`${where}: ${base.length} base prediction values for ${dimensions} dimensions`);
+        // Nodes arrive as one list across trees; group them by tree id.
+        const byTree = new Map();
+        for (const node of parameters.messages(1)) {
+            const treeId = node.int(1);
+            let list = byTree.get(treeId);
+            if (!list) {
+                list = [];
+                byTree.set(treeId, list);
+            }
+            list.push(node);
+        }
+        const trees = [...byTree.keys()].sort((a, b) => a - b).map((treeId) => this.tree(treeId, byTree.get(treeId), dimensions, where));
+        return { dimensions, base: base.length === 0 ? new Array(dimensions).fill(0) : base, trees, transform };
+    }
+    /** One tree in columns, root first, children as positions; checks that it is a tree. */
+    tree(treeId, nodes, dimensions, where) {
+        const what = `${where}, tree ${treeId}`;
+        const byId = new Map();
+        for (const node of nodes) {
+            const id = node.int(2);
+            if (byId.has(id))
+                this.fail(`${what}: node ${id} appears twice`);
+            byId.set(id, node);
+        }
+        const children = new Set();
+        for (const node of nodes) {
+            if (node.int(3) === 6)
+                continue;
+            children.add(node.int(12));
+            children.add(node.int(13));
+        }
+        const roots = [...byId.keys()].filter((id) => !children.has(id));
+        if (roots.length !== 1)
+            this.fail(`${what} has ${roots.length} root nodes`);
+        // Breadth first from the root: positions in the order nodes are reached.
+        const order = [roots[0]];
+        const position = new Map([[roots[0], 0]]);
+        for (let i = 0; i < order.length; i += 1) {
+            const node = byId.get(order[i]);
+            if (node.int(3) === 6)
+                continue;
+            for (const child of [node.int(12), node.int(13)]) {
+                if (!byId.has(child))
+                    this.fail(`${what}: node ${order[i]} branches to node ${child}, which does not exist`);
+                if (position.has(child))
+                    this.fail(`${what}: node ${child} is reached twice (not a tree)`);
+                position.set(child, order.length);
+                order.push(child);
+            }
+        }
+        if (order.length !== byId.size)
+            this.fail(`${what}: ${byId.size - order.length} nodes are unreachable from the root`);
+        const tree = { behaviors: [], features: [], thresholds: [], trueChildren: [], falseChildren: [], missingTrue: [], leafStarts: [], leafIndices: [], leafValues: [] };
+        for (const id of order) {
+            const node = byId.get(id);
+            const behavior = node.int(3);
+            if (behavior < 0 || behavior > 6)
+                this.fail(`${what}: node ${id} has an unknown behavior ${behavior}`);
+            const leaf = behavior === 6;
+            tree.behaviors.push(behavior);
+            tree.features.push(leaf ? 0 : node.int(10));
+            tree.thresholds.push(leaf ? 0 : node.double(11));
+            tree.trueChildren.push(leaf ? -1 : position.get(node.int(12)));
+            tree.falseChildren.push(leaf ? -1 : position.get(node.int(13)));
+            tree.missingTrue.push(node.bool(14));
+            tree.leafStarts.push(tree.leafIndices.length);
+            if (leaf) {
+                for (const info of node.messages(20)) {
+                    const index = info.int(1);
+                    if (index >= dimensions)
+                        this.fail(`${what}: leaf ${id} adds to dimension ${index} of ${dimensions}`);
+                    tree.leafIndices.push(index);
+                    tree.leafValues.push(info.double(2));
+                }
+            }
+        }
+        tree.leafStarts.push(tree.leafIndices.length);
+        return tree;
+    }
+    imputer(body, where) {
+        let imputed;
+        if (body.has(1))
+            imputed = { double: body.double(1) };
+        else if (body.has(2))
+            imputed = { int64: body.int(2) };
+        else if (body.has(3))
+            imputed = { string: body.string(3) };
+        else if (body.has(4))
+            imputed = { doubles: body.message(4).doubles(1) };
+        else if (body.has(5))
+            imputed = { int64s: body.message(5).ints(1) };
+        else if (body.has(6))
+            imputed = { stringDictionary: Object.fromEntries(body.message(6).messages(1).map((entry) => [entry.string(1), entry.double(2)])) };
+        else if (body.has(7))
+            imputed = { int64Dictionary: Object.fromEntries(body.message(7).messages(1).map((entry) => [String(entry.int(1)), entry.double(2)])) };
+        else
+            this.fail(`${where}: an imputer without an imputed value`);
+        const imputer = { kind: 'imputer', imputed };
+        if (body.has(11))
+            imputer.replace = { double: body.double(11) };
+        else if (body.has(12))
+            imputer.replace = { int64: body.int(12) };
+        else if (body.has(13))
+            imputer.replace = { string: body.string(13) };
+        return imputer;
+    }
+}
+function labelCount(labels) {
+    return 'strings' in labels ? labels.strings.length : labels.int64s.length;
+}
+/** Parses a model's protobuf bytes; `file` names it in errors. */
+export function parseModel(bytes, file) {
+    const reader = new Reader(file);
+    try {
+        return reader.model(decodeMessage(bytes), 'the model');
+    }
+    catch (error) {
+        if (error instanceof ProtobufError)
+            reader.fail(`not a readable Core ML model (${error.message})`);
+        throw error;
+    }
+}
+/**
+ * The protobuf of an `.mlmodel` file, or of the root model of an `.mlpackage`
+ * (its Manifest.json names the specification file under Data/).
+ */
+export function readModelBytes(file) {
+    if (!existsSync(file))
+        throw new ModelError(`Core ML model not found: ${file}`);
+    if (!statSync(file).isDirectory())
+        return readFileSync(file);
+    const manifestPath = path.join(file, 'Manifest.json');
+    if (!existsSync(manifestPath))
+        throw new ModelError(`${path.basename(file)}: no Manifest.json in the package`);
+    let specPath;
+    try {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const root = manifest.rootModelIdentifier ? manifest.itemInfoEntries?.[manifest.rootModelIdentifier]?.path : undefined;
+        if (root)
+            specPath = path.join(file, 'Data', root);
+    }
+    catch {
+        throw new ModelError(`${path.basename(file)}: Manifest.json is not valid JSON`);
+    }
+    if (!specPath || !existsSync(specPath))
+        throw new ModelError(`${path.basename(file)}: the package's Manifest.json names no model specification`);
+    return readFileSync(specPath);
+}
+// --- Checking what the top-level model offers the app ---
+/** The class Xcode generates for `file`: its base name as a Swift identifier. */
+export function modelClassName(file) {
+    const base = path.basename(file).replace(/\.(mlmodel|mlpackage)$/, '');
+    const cleaned = base.replace(/[^A-Za-z0-9_]/g, '_');
+    return /^[0-9]/.test(cleaned) || cleaned === '' ? `_${cleaned}` : cleaned;
+}
+// --- Generating the Swift ---
+const SWIFT_KEYWORDS = new Set([
+    'associatedtype', 'class', 'deinit', 'enum', 'extension', 'fileprivate', 'func', 'import', 'init', 'inout', 'internal', 'let', 'open', 'operator',
+    'private', 'precedencegroup', 'protocol', 'public', 'rethrows', 'static', 'struct', 'subscript', 'typealias', 'var', 'break', 'case', 'catch',
+    'continue', 'default', 'defer', 'do', 'else', 'fallthrough', 'for', 'guard', 'if', 'in', 'repeat', 'return', 'throw', 'switch', 'where', 'while',
+    'Any', 'as', 'await', 'false', 'is', 'nil', 'self', 'Self', 'super', 'throws', 'true', 'try', 'Type', 'Protocol',
+]);
+/** A feature name as a Swift identifier, as Xcode spells it: other characters become `_`, keywords get backticks. */
+export function swiftIdentifier(name) {
+    let cleaned = name.replace(/[^A-Za-z0-9_]/g, '_');
+    if (cleaned === '' || /^[0-9]/.test(cleaned))
+        cleaned = `_${cleaned}`;
+    return SWIFT_KEYWORDS.has(cleaned) ? `\`${cleaned}\`` : cleaned;
+}
+/** The Swift type Xcode gives a feature. */
+export function swiftType(feature) {
+    switch (feature.type) {
+        case 'int64':
+            return 'Int64';
+        case 'double':
+            return 'Double';
+        case 'string':
+            return 'String';
+        case 'multiArray':
+            return 'MLMultiArray';
+        case 'dictionary':
+            return feature.keyType === 'string' ? '[String : Double]' : '[Int64 : Double]';
+    }
+}
+/** `MLFeatureValue` for a stored property of the input class. */
+function featureValueExpression(feature, variable) {
+    switch (feature.type) {
+        case 'int64':
+            return `MLFeatureValue(int64: ${variable})`;
+        case 'double':
+            return `MLFeatureValue(double: ${variable})`;
+        case 'string':
+            return `MLFeatureValue(string: ${variable})`;
+        case 'multiArray':
+            return `MLFeatureValue(multiArray: ${variable})`;
+        case 'dictionary':
+            return `MLFeatureValue(_doubles: ${variable})`;
+    }
+}
+/** Reading an output property back from its `MLFeatureValue`. */
+function outputAccessor(feature) {
+    const value = `provider.featureValue(for: ${JSON.stringify(feature.name)})!`;
+    switch (feature.type) {
+        case 'int64':
+            return `${value}.int64Value`;
+        case 'double':
+            return `${value}.doubleValue`;
+        case 'string':
+            return `${value}.stringValue`;
+        case 'multiArray':
+            return `${value}.multiArrayValue!`;
+        case 'dictionary':
+            return `${value}._doubles(keyedBy: ${feature.keyType === 'string' ? 'String' : 'Int64'}.self)`;
+    }
+}
+function typeWords(feature) {
+    switch (feature.type) {
+        case 'int64':
+            return 'integer value';
+        case 'double':
+            return 'double value';
+        case 'string':
+            return 'string value';
+        case 'multiArray':
+            return `${feature.shape.length > 0 ? `${feature.shape.join(' by ')} ` : ''}${{ double: 'Double', float32: 'Float32', float16: 'Float16', int32: 'Int32', int8: 'Int8' }[feature.dataType]} MLMultiArray`;
+        case 'dictionary':
+            return `dictionary of ${feature.keyType === 'string' ? 'String' : 'Int64'} to Double values`;
+    }
+}
+function docComment(feature, indent) {
+    const text = feature.shortDescription ? `${feature.shortDescription.replace(/\s+/g, ' ')} as ${typeWords(feature)}` : `${feature.name} as ${typeWords(feature)}`;
+    return `${indent}/// ${text}`;
+}
+/**
+ * The spec as JSON for the generated file: objects one key per line (a short
+ * one whose values are all numbers, strings or lists of them on one line),
+ * lists of numbers and strings on one line, NaN and infinities as the strings
+ * the CoreML module's decoder converts back ("nan", "inf", "-inf").
+ */
+export function specJSON(value, indent = '') {
+    if (typeof value === 'number') {
+        if (Number.isNaN(value))
+            return '"nan"';
+        if (value === Infinity)
+            return '"inf"';
+        if (value === -Infinity)
+            return '"-inf"';
+        return Object.is(value, -0) ? '-0.0' : String(value);
+    }
+    if (typeof value === 'string' || typeof value === 'boolean' || value === null)
+        return JSON.stringify(value);
+    const inner = `${indent}  `;
+    if (Array.isArray(value)) {
+        if (value.every((item) => typeof item !== 'object' || item === null))
+            return `[${value.map((item) => specJSON(item)).join(', ')}]`;
+        if (value.length === 0)
+            return '[]';
+        return `[\n${value.map((item) => `${inner}${specJSON(item, inner)}`).join(',\n')}\n${indent}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+        if (entries.length === 0)
+            return '{}';
+        const flat = entries.every(([, item]) => typeof item !== 'object' || item === null || (Array.isArray(item) && item.every((x) => typeof x !== 'object' || x === null)));
+        if (flat) {
+            const line = `{${entries.map(([key, item]) => `${JSON.stringify(key)}: ${specJSON(item)}`).join(', ')}}`;
+            if (line.length <= 100)
+                return line;
+        }
+        return `{\n${entries.map(([key, item]) => `${inner}${JSON.stringify(key)}: ${specJSON(item, inner)}`).join(',\n')}\n${indent}}`;
+    }
+    throw new Error(`cannot write ${typeof value} as JSON`);
+}
+/** A raw string literal whose delimiter cannot occur in `text`. */
+function rawStringLiteral(text) {
+    let hashes = '#';
+    while (text.includes(`"${hashes}`))
+        hashes += '#';
+    return `${hashes}"""\n${text}\n"""${hashes}`;
+}
+/**
+ * The Swift Xcode would generate for the model, with the model itself
+ * embedded: the class with `model: MLModel`, `urlOfModelInThisBundle`, the
+ * initializers and `load` functions, `prediction` with one argument per input
+ * and with an `Input`, `predictions(inputs:)`; the Input and Output feature
+ * providers. `file` is the model's path (for the header comment).
+ */
+export function generateModelSource(className, spec, file) {
+    const { inputs, outputs } = spec.description;
+    const input = `${className}Input`;
+    const output = `${className}Output`;
+    const ids = (features) => features.map((feature) => swiftIdentifier(feature.name));
+    const inputIds = ids(inputs);
+    const outputIds = ids(outputs);
+    const parameters = inputs.map((feature, i) => `${inputIds[i]}: ${swiftType(feature)}`).join(', ');
+    const forwarded = inputIds.map((id) => `${id}: ${id}`).join(', ');
+    const description = spec.description.metadata?.shortDescription;
+    const lines = [];
+    const push = (...more) => {
+        lines.push(...more);
+    };
+    push(`// Generated by @swiftbrowser/cli from ${path.basename(file)}; rewritten on every build.`, '// What Xcode generates for a Core ML model, with the model compiled into the', '// class: the JSON below is its specification, which the CoreML module', '// evaluates (docs/ops-protocol.md, "Core ML models").', 'import CoreML', 'import Foundation', '', `private let _${className}Specification = ${rawStringLiteral(specJSON(stripDescriptions(spec)))}`, '', `/// Model Prediction Input Type`, `class ${input} : MLFeatureProvider {`);
+    inputs.forEach((feature, i) => push('', docComment(feature, '    '), `    var ${inputIds[i]}: ${swiftType(feature)}`));
+    push('', `    var featureNames: Set<String> { [${inputs.map((f) => JSON.stringify(f.name)).join(', ')}] }`, '', '    func featureValue(for featureName: String) -> MLFeatureValue? {', ...inputs.map((feature, i) => `        if featureName == ${JSON.stringify(feature.name)} { return ${featureValueExpression(feature, inputIds[i])} }`), '        return nil', '    }', '', `    init(${parameters}) {`, ...inputIds.map((id) => `        self.${id.replace(/`/g, '')} = ${id}`), '    }', '}', '', `/// Model Prediction Output Type`, `class ${output} : MLFeatureProvider {`, '', '    /// Source provided by CoreML', '    private let provider : MLFeatureProvider');
+    outputs.forEach((feature, i) => push('', docComment(feature, '    '), `    var ${outputIds[i]}: ${swiftType(feature)} {`, `        ${outputAccessor(feature)}`, '    }'));
+    push('', '    var featureNames: Set<String> {', '        provider.featureNames', '    }', '', '    func featureValue(for featureName: String) -> MLFeatureValue? {', '        provider.featureValue(for: featureName)', '    }', '', `    init(${outputs.map((feature, i) => `${outputIds[i]}: ${swiftType(feature)}`).join(', ')}) {`, `        self.provider = try! MLDictionaryFeatureProvider(dictionary: [${outputs.length === 0 ? ':' : outputs.map((feature, i) => `${JSON.stringify(feature.name)} : ${featureValueExpression(feature, outputIds[i])}`).join(', ')}])`, '    }', '', '    init(features: MLFeatureProvider) {', '        self.provider = features', '    }', '}', '', '/// Class for model loading and prediction', ...(description ? [`/// ${description.replace(/\s+/g, ' ')}`] : []), `class ${className} {`, '    let model: MLModel', '', '    /// URL of model assuming it was installed in the same bundle as this class', '    class var urlOfModelInThisBundle : URL {', `        MLModel._compiledModelURL(named: ${JSON.stringify(className)}, specification: _${className}Specification)`, '    }', '', '    /// Construct a model with explicit path to mlmodelc file', '    init(model: MLModel) {', '        self.model = model', '    }', '', '    /// Construct a model that automatically loads the model from the app\'s bundle.', '    @available(*, deprecated, message: "Use init(configuration:) instead and handle errors appropriately.")', '    convenience init() {', '        try! self.init(contentsOf: type(of:self).urlOfModelInThisBundle)', '    }', '', '    /// Construct a model that automatically loads the model from the app\'s bundle.', '    convenience init(configuration: MLModelConfiguration) throws {', '        try self.init(contentsOf: type(of:self).urlOfModelInThisBundle, configuration: configuration)', '    }', '', '    /// Construct a model with explicit path to mlmodelc file', '    convenience init(contentsOf modelURL: URL) throws {', '        try self.init(model: MLModel(contentsOf: modelURL))', '    }', '', '    /// Construct a model with explicit path to mlmodelc file and configuration.', '    convenience init(contentsOf modelURL: URL, configuration: MLModelConfiguration) throws {', '        try self.init(model: MLModel(contentsOf: modelURL, configuration: configuration))', '    }', '', '    /// Construct and load the model asynchronously.', `    class func load(configuration: MLModelConfiguration = MLModelConfiguration(), completionHandler handler: @escaping (Swift.Result<${className}, Error>) -> Void) {`, `        load(contentsOf: self.urlOfModelInThisBundle, configuration: configuration, completionHandler: handler)`, '    }', '', '    /// Construct and load the model asynchronously.', `    class func load(configuration: MLModelConfiguration = MLModelConfiguration()) async throws -> ${className} {`, `        try await load(contentsOf: self.urlOfModelInThisBundle, configuration: configuration)`, '    }', '', '    /// Construct and load the model from a URL asynchronously.', `    class func load(contentsOf modelURL: URL, configuration: MLModelConfiguration = MLModelConfiguration(), completionHandler handler: @escaping (Swift.Result<${className}, Error>) -> Void) {`, '        MLModel.load(contentsOf: modelURL, configuration: configuration) { result in', '            switch result {', '            case .failure(let error):', '                handler(.failure(error))', '            case .success(let model):', `                handler(.success(${className}(model: model)))`, '            }', '        }', '    }', '', '    /// Construct and load the model from a URL asynchronously.', `    class func load(contentsOf modelURL: URL, configuration: MLModelConfiguration = MLModelConfiguration()) async throws -> ${className} {`, '        let model = try await MLModel.load(contentsOf: modelURL, configuration: configuration)', `        return ${className}(model: model)`, '    }', '', '    /// Make a prediction using the structured interface', `    func prediction(input: ${input}) throws -> ${output} {`, '        try prediction(input: input, options: MLPredictionOptions())', '    }', '', '    /// Make a prediction using the structured interface', `    func prediction(input: ${input}, options: MLPredictionOptions) throws -> ${output} {`, '        let outFeatures = try model.prediction(from: input, options: options)', `        return ${output}(features: outFeatures)`, '    }', '', '    /// Make a prediction using the convenience interface', `    func prediction(${parameters}) throws -> ${output} {`, `        let input_ = ${input}(${forwarded})`, '        return try prediction(input: input_)', '    }', '', '    /// Make a batch prediction using the structured interface', `    func predictions(inputs: [${input}], options: MLPredictionOptions = MLPredictionOptions()) throws -> [${output}] {`, '        let batchIn = MLArrayBatchProvider(array: inputs)', '        let batchOut = try model.predictions(from: batchIn, options: options)', `        var results : [${output}] = []`, '        results.reserveCapacity(inputs.count)', '        for i in 0..<batchOut.count {', '            let outProvider = batchOut.features(at: i)', `            results.append(${output}(features: outProvider))`, '        }', '        return results', '    }', '}', '');
+    return lines.join('\n');
+}
+/** The spec without the feature descriptions' prose (it goes into doc comments, not the JSON). */
+function stripDescriptions(spec) {
+    const strip = (features) => features.map((feature) => {
+        const { shortDescription: _ignored, ...rest } = feature;
+        return rest;
+    });
+    const model = spec.model;
+    const strippedModel = 'models' in model ? { ...model, models: model.models.map(stripDescriptions) } : model;
+    return { ...spec, description: { ...spec.description, inputs: strip(spec.description.inputs), outputs: strip(spec.description.outputs) }, model: strippedModel };
+}
+/** Reads, checks and generates the Swift for one model. */
+export function compileModel(file) {
+    const spec = parseModel(readModelBytes(file), file);
+    const className = modelClassName(file);
+    return { file, className, spec, source: generateModelSource(className, spec, file) };
+}
+//# sourceMappingURL=coreml.js.map