@particle/tachyon-image 0.1.0

package/dist/manifest/imageManifestV1.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Legacy Qualcomm-style `image_manifest_v1` — the manifest.json that ships in
+ * the factory zip today and that `particle flash --tachyon` already parses
+ * (targets[].qcm6490.edl.{base,firehose,program_xml[],patch_xml[]}). The lib
+ * must read AND emit it for back-compat while the new particle_image_v1 rolls out.
+ */
+export interface EdlTarget {
+    base: string;
+    firehose: string;
+    program_xml: string[];
+    patch_xml: string[];
+}
+export interface ImageManifestV1 {
+    $schema?: string;
+    release_name?: string;
+    version?: string;
+    region?: string;
+    variant?: string;
+    platform?: string;
+    board?: string;
+    os?: string;
+    distribution?: string;
+    distribution_version?: string;
+    distribution_variant?: string;
+    sources?: unknown;
+    targets: Array<Record<string, {
+        edl: EdlTarget;
+    }>>;
+}
+export declare function parseImageManifestV1(json: string | object): ImageManifestV1;
+/** Extract the single EDL target block (platform-keyed) from the manifest. */
+export declare function edlOf(m: ImageManifestV1): {
+    platform: string;
+    edl: EdlTarget;
+};
+export declare function buildImageManifestV1(m: ImageManifestV1): string;

package/dist/manifest/imageManifestV1.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Legacy Qualcomm-style `image_manifest_v1` — the manifest.json that ships in
+ * the factory zip today and that `particle flash --tachyon` already parses
+ * (targets[].qcm6490.edl.{base,firehose,program_xml[],patch_xml[]}). The lib
+ * must read AND emit it for back-compat while the new particle_image_v1 rolls out.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseImageManifestV1 = parseImageManifestV1;
+exports.edlOf = edlOf;
+exports.buildImageManifestV1 = buildImageManifestV1;
+function parseImageManifestV1(json) {
+    const m = typeof json === 'string' ? JSON.parse(json) : json;
+    if (!Array.isArray(m.targets) || m.targets.length === 0) {
+        throw new Error('image_manifest_v1: missing targets[]');
+    }
+    return m;
+}
+/** Extract the single EDL target block (platform-keyed) from the manifest. */
+function edlOf(m) {
+    const target = m.targets[0];
+    const platform = Object.keys(target)[0];
+    const edl = target[platform]?.edl;
+    if (!edl)
+        throw new Error('image_manifest_v1: target has no edl block');
+    return { platform, edl };
+}
+function buildImageManifestV1(m) {
+    return JSON.stringify(m, null, 4) + '\n';
+}

package/dist/manifest/particleImageV1.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The Particle-owned `particle_image_v1` manifest — first entry of the image
+ * ZIP. It carries the per-partition operation graph + hashes + an embedded
+ * ed25519/JCS signature, and a `format` capability descriptor declaring which
+ * of factory / ota-image / ota-boot this archive can produce.
+ */
+import type { Compression, FormatKind, Group, Role, Slot, SigningInfo, GptPatch, ChunkRef } from '../model/types';
+export declare const PARTICLE_IMAGE_SCHEMA = "https://linux-dist.particle.io/schema/particle_image_v1.json";
+/** Serialized form of a PartitionOp inside the manifest (camelCase preserved). */
+export type ManifestOp = {
+    op: 'program';
+    source?: string;
+    chunks?: ChunkRef[];
+    sparse?: boolean;
+    compression?: Compression;
+    uncompressed_size?: number;
+    file_sector_offset?: number;
+    sha256?: string;
+    payload_sha256?: string;
+} | {
+    op: 'erase';
+} | {
+    op: 'zero';
+    source?: string;
+} | {
+    op: 'gpt';
+    which: 'primary' | 'backup';
+    source: string;
+} | {
+    op: 'patch';
+    patches: GptPatch[];
+};
+export interface ManifestPartition {
+    label: string;
+    lun: number;
+    slot: Slot;
+    role: Role;
+    group: Group;
+    size?: number;
+    start_sector?: number;
+    num_partition_sectors?: number;
+    type_guid?: string;
+    signed?: boolean;
+    image_id?: string | null;
+    ops: ManifestOp[];
+}
+export interface ParticleImageV1 {
+    $schema: string;
+    schema_version: 1;
+    release_name?: string;
+    version?: string;
+    platform: string;
+    board?: string;
+    region?: string;
+    variant?: string;
+    distribution?: string;
+    distribution_version?: string;
+    sector_size: number;
+    firehose?: string;
+    format: {
+        kind: FormatKind;
+        emittable: FormatKind[];
+        slots_present: Slot[];
+        groups: Partial<Record<Group, string[]>>;
+    };
+    partitions: ManifestPartition[];
+    signing: {
+        profile: SigningInfo['profile'];
+        key_id?: string;
+        algorithm: 'ed25519';
+        digest_algorithm: 'sha256';
+        canonicalization: 'jcs';
+        signature?: string;
+    };
+}
+export declare const MANIFEST_ENTRY_NAME = "particle-image.json";
+export declare function parseParticleImageV1(json: string | object): ParticleImageV1;
+export declare function buildParticleImageV1(m: ParticleImageV1): string;

package/dist/manifest/particleImageV1.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANIFEST_ENTRY_NAME = exports.PARTICLE_IMAGE_SCHEMA = void 0;
+exports.parseParticleImageV1 = parseParticleImageV1;
+exports.buildParticleImageV1 = buildParticleImageV1;
+exports.PARTICLE_IMAGE_SCHEMA = 'https://linux-dist.particle.io/schema/particle_image_v1.json';
+exports.MANIFEST_ENTRY_NAME = 'particle-image.json';
+function parseParticleImageV1(json) {
+    const m = (typeof json === 'string' ? JSON.parse(json) : json);
+    if (m.schema_version !== 1) {
+        throw new Error(`particle_image_v1: unsupported schema_version ${m.schema_version}`);
+    }
+    if (!Array.isArray(m.partitions))
+        throw new Error('particle_image_v1: missing partitions[]');
+    if (!m.format?.groups)
+        throw new Error('particle_image_v1: missing format.groups');
+    return m;
+}
+function buildParticleImageV1(m) {
+    return JSON.stringify(m, null, 2) + '\n';
+}

package/dist/model/types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The operation-graph model — the single in-memory representation that every
+ * importer (Qualcomm manifest/rawprogram/patch XML, particle_image_v1) parses
+ * INTO and every exporter (qdl XML, particle_image_v1 zip) builds FROM.
+ *
+ * It is deliberately a superset of the Qualcomm rawprogram/patch grammar so we
+ * can losslessly round-trip a real factory image AND describe Particle-specific
+ * OTA semantics (slots, groups, per-partition hashes, signing).
+ */
+export declare const DEFAULT_SECTOR_SIZE = 4096;
+export type Slot = 'a' | 'b' | 'none';
+export type Role = 'boot' | 'firmware' | 'efi' | 'system' | 'userdata' | 'persist' | 'nvm' | 'gpt' | 'other';
+export type Group = 'BOOT' | 'FIRMWARE' | 'A' | 'B' | 'USER' | 'NVM' | 'OTHER';
+export type Compression = 'none' | 'gzip' | 'zstd';
+export type FormatKind = 'factory' | 'ota-image' | 'ota-boot';
+/**
+ * One contiguous chunk of a partition payload. The real factory writes the OS
+ * as ~61 sequential <program> chunks (sysfs_1.ext4 …); each is a ChunkRef.
+ */
+export interface ChunkRef {
+    /** Entry name (inside the zip) or filesystem path of the payload chunk. */
+    source: string;
+    /** Absolute LBA (LUN-relative) where this chunk is written. */
+    startSector: number;
+    /** Number of sectors this chunk occupies on the partition. */
+    numSectors: number;
+    /** Sector offset into the source file (rawprogram file_sector_offset). */
+    fileSectorOffset?: number;
+    /** Android sparse image. */
+    sparse?: boolean;
+}
+/** A GPT header/table patch directive (rawprogram patch*.xml <patch>). */
+export interface GptPatch {
+    /** May be a literal LBA or an expression, e.g. "NUM_DISK_SECTORS-5.". */
+    startSector: number | string;
+    byteOffset: number;
+    sizeBytes: number;
+    /** Literal or expression, e.g. "NUM_DISK_SECTORS-6." or "CRC32(2,4096)". */
+    value: string;
+    /** Target file, e.g. "gpt_main0.bin" or "DISK". */
+    filename: string;
+    what?: string;
+}
+/** A single operation applied to a partition, in order. */
+export type PartitionOp = {
+    op: 'program';
+    /** Single-file payload (mutually exclusive with chunks). */
+    source?: string;
+    /** Multi-chunk payload (the sysfs_N pattern). */
+    chunks?: ChunkRef[];
+    sparse?: boolean;
+    compression?: Compression;
+    /** Size of the decompressed stream handed to the writer. */
+    uncompressedSize?: number;
+    fileSectorOffset?: number;
+    /** sha256 of the (possibly compressed) zip entry bytes. */
+    sha256?: string;
+    /** sha256 of the fully-expanded raw image (holes as zeros). */
+    payloadSha256?: string;
+} | {
+    op: 'erase';
+} | {
+    op: 'zero';
+    source?: string;
+} | {
+    op: 'gpt';
+    which: 'primary' | 'backup';
+    source: string;
+} | {
+    op: 'patch';
+    patches: GptPatch[];
+};
+export interface Partition {
+    label: string;
+    lun: number;
+    slot: Slot;
+    role: Role;
+    group: Group;
+    /** Declared size in bytes (from partition_ext size_in_kb); 0/undefined = grow. */
+    sizeBytes?: number;
+    startSector?: number;
+    numSectors?: number;
+    typeGuid?: string;
+    readonly?: boolean;
+    /** Qualcomm-signed boot/firmware blob. */
+    signed?: boolean;
+    /** sectoolsv2 image-id when signed (e.g. "UEFI"). */
+    imageId?: string;
+    ops: PartitionOp[];
+}
+export interface SigningInfo {
+    profile: 'test' | 'prod' | 'none';
+    keyId?: string;
+    algorithm: 'ed25519';
+    digestAlgorithm: 'sha256';
+    canonicalization: 'jcs';
+    /** base64 signature over the canonical digest of the manifest (blank sig). */
+    signature?: string;
+}
+export interface ImageMeta {
+    schemaVersion: 1;
+    releaseName?: string;
+    version?: string;
+    platform: string;
+    board?: string;
+    region?: string;
+    variant?: string;
+    os?: string;
+    distribution?: string;
+    distributionVersion?: string;
+    sectorSize: number;
+}
+/** Declares which emit formats this image can produce and its partition groups. */
+export interface FormatDescriptor {
+    kind: FormatKind;
+    emittable: FormatKind[];
+    slotsPresent: Slot[];
+    /** group name -> ordered partition labels */
+    groups: Partial<Record<Group, string[]>>;
+}
+/**
+ * The whole image. Partitions are stored flat (each carries its `lun`); group
+ * by lun with `partitionsByLun()` when emitting per-LUN rawprogram files.
+ */
+export interface ImageModel {
+    meta: ImageMeta;
+    format: FormatDescriptor;
+    /** In flash order (LUN1, LUN2, LUN4, LUN0, LUN5). */
+    partitions: Partition[];
+    signing: SigningInfo;
+    /** Firehose programmer filename (prog_firehose_*.elf). */
+    firehose?: string;
+}
+export declare function partitionsByLun(model: ImageModel): Map<number, Partition[]>;
+/** Derive slot/role/group from a partition label and its LUN. */
+export declare function classify(label: string, lun: number): {
+    slot: Slot;
+    role: Role;
+    group: Group;
+};

package/dist/model/types.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * The operation-graph model — the single in-memory representation that every
+ * importer (Qualcomm manifest/rawprogram/patch XML, particle_image_v1) parses
+ * INTO and every exporter (qdl XML, particle_image_v1 zip) builds FROM.
+ *
+ * It is deliberately a superset of the Qualcomm rawprogram/patch grammar so we
+ * can losslessly round-trip a real factory image AND describe Particle-specific
+ * OTA semantics (slots, groups, per-partition hashes, signing).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SECTOR_SIZE = void 0;
+exports.partitionsByLun = partitionsByLun;
+exports.classify = classify;
+exports.DEFAULT_SECTOR_SIZE = 4096;
+function partitionsByLun(model) {
+    const m = new Map();
+    for (const p of model.partitions) {
+        const arr = m.get(p.lun) ?? [];
+        arr.push(p);
+        m.set(p.lun, arr);
+    }
+    return m;
+}
+/** Derive slot/role/group from a partition label and its LUN. */
+function classify(label, lun) {
+    const slot = label.endsWith('_a') ? 'a' : label.endsWith('_b') ? 'b' : 'none';
+    const base = label.replace(/_[ab]$/, '');
+    if (label === 'PrimaryGPT' || label === 'BackupGPT') {
+        return { slot: 'none', role: 'gpt', group: 'OTHER' };
+    }
+    if (base === 'efi')
+        return { slot, role: 'efi', group: slot === 'b' ? 'B' : 'A' };
+    if (base === 'system')
+        return { slot, role: 'system', group: slot === 'b' ? 'B' : 'A' };
+    if (base === 'userdata')
+        return { slot: 'none', role: 'userdata', group: 'USER' };
+    if (base === 'persist')
+        return { slot: 'none', role: 'persist', group: 'USER' };
+    if (base === 'xbl' || base === 'xbl_config')
+        return { slot, role: 'boot', group: 'BOOT' };
+    if (['fsc', 'fsg', 'modemst1', 'modemst2', 'nvdata1', 'nvdata2'].includes(base)) {
+        return { slot: 'none', role: 'nvm', group: 'NVM' };
+    }
+    if (lun === 4)
+        return { slot, role: 'firmware', group: 'FIRMWARE' };
+    return { slot, role: 'other', group: 'OTHER' };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Server-side consumer helpers. A cloud/release server that hosts Particle images
+ * uses these to (1) ingest+validate an uploaded image and (2) serve a per-slot
+ * OTA view to a device. It is a thin composition of the lib's parse/validate/
+ * expand primitives — the server owns transport/storage, not image logic.
+ *
+ * See OTA_SERVER.md for the integration contract.
+ */
+import { KeyObject } from 'node:crypto';
+import { type ValidateReport } from '../validate';
+import type { ParticleImageV1 } from '../manifest/particleImageV1';
+import type { Slot } from '../model/types';
+export interface IngestResult {
+    manifest: ParticleImageV1;
+    report: ValidateReport;
+    signatureOk: boolean;
+}
+/** Ingest an uploaded image zip: read the manifest, verify signature, validate. */
+export declare function ingestImage(zipPath: string, opts: {
+    publicKey: string | Buffer | KeyObject;
+}): Promise<IngestResult>;
+/**
+ * Produce the OTA-image view a server would hand a device asking to update a
+ * given slot — the manifest subset + the exact payload entry names to stream.
+ */
+export declare function otaViewForSlot(manifest: ParticleImageV1, slot: Slot): {
+    manifest: ParticleImageV1;
+    entries: string[];
+};

package/dist/server/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestImage = ingestImage;
+exports.otaViewForSlot = otaViewForSlot;
+const zip_1 = require("../zip");
+const validate_1 = require("../validate");
+const expand_1 = require("../format/expand");
+const sign_1 = require("../signing/sign");
+/** Ingest an uploaded image zip: read the manifest, verify signature, validate. */
+async function ingestImage(zipPath, opts) {
+    const manifest = await (0, zip_1.readManifestFromZip)(zipPath);
+    const zipEntryNames = (await (0, zip_1.listImageZip)(zipPath)).map((e) => e.name);
+    const report = (0, validate_1.validateManifest)(manifest, { publicKey: opts.publicKey, zipEntryNames });
+    const signatureOk = manifest.signing.profile === 'none' ? true : (0, sign_1.verifyManifest)(manifest, opts.publicKey);
+    return { manifest, report, signatureOk };
+}
+/**
+ * Produce the OTA-image view a server would hand a device asking to update a
+ * given slot — the manifest subset + the exact payload entry names to stream.
+ */
+function otaViewForSlot(manifest, slot) {
+    const view = (0, expand_1.expand)(manifest, { kind: 'ota-image', slot });
+    const entries = [];
+    for (const p of view.partitions) {
+        for (const op of p.ops) {
+            if (op.op === 'program') {
+                if (op.source)
+                    entries.push(op.source);
+                for (const c of op.chunks ?? [])
+                    entries.push(c.source);
+            }
+        }
+    }
+    return { manifest: view, entries };
+}

package/dist/signing/jcs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deterministic JSON canonicalization for signing. A pragmatic RFC 8785 (JCS)
+ * subset sufficient for our manifest: object keys sorted lexicographically by
+ * UTF-16 code unit, no insignificant whitespace, arrays in order. Our manifest
+ * values are strings / integers / booleans / nested objects / arrays — no
+ * floats or exotic numbers — so JSON.stringify of a key-sorted structure is a
+ * stable canonical form across the TS consumers (composer CLI, cli, device).
+ */
+export declare function canonicalize(value: unknown): string;

package/dist/signing/jcs.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalize = canonicalize;
+/**
+ * Deterministic JSON canonicalization for signing. A pragmatic RFC 8785 (JCS)
+ * subset sufficient for our manifest: object keys sorted lexicographically by
+ * UTF-16 code unit, no insignificant whitespace, arrays in order. Our manifest
+ * values are strings / integers / booleans / nested objects / arrays — no
+ * floats or exotic numbers — so JSON.stringify of a key-sorted structure is a
+ * stable canonical form across the TS consumers (composer CLI, cli, device).
+ */
+function canonicalize(value) {
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return '[' + value.map((v) => canonicalize(v)).join(',') + ']';
+    }
+    if (typeof value === 'object') {
+        const obj = value;
+        const keys = Object.keys(obj)
+            .filter((k) => obj[k] !== undefined)
+            .sort();
+        return ('{' +
+            keys.map((k) => JSON.stringify(k) + ':' + canonicalize(obj[k])).join(',') +
+            '}');
+    }
+    throw new Error(`canonicalize: unsupported value type ${typeof value}`);
+}

package/dist/signing/sign.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ed25519 manifest signing + verification.
+ *
+ * The signature covers the JCS-canonical bytes of the manifest with
+ * `signing.signature` blanked to "". Node's native crypto handles ed25519
+ * (algorithm = null), so no third-party crypto dependency.
+ */
+import { KeyObject } from 'node:crypto';
+import type { ParticleImageV1 } from '../manifest/particleImageV1';
+/** The exact bytes that get signed: JCS(manifest with signing.signature=""). */
+export declare function signingBytes(manifest: ParticleImageV1): Buffer;
+/** Sign in place: sets manifest.signing.signature (base64) and returns the manifest. */
+export declare function signManifest(manifest: ParticleImageV1, privateKey: string | Buffer | KeyObject): ParticleImageV1;
+/** Verify the embedded signature against a public key. Returns true/false. */
+export declare function verifyManifest(manifest: ParticleImageV1, publicKey: string | Buffer | KeyObject): boolean;

package/dist/signing/sign.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signingBytes = signingBytes;
+exports.signManifest = signManifest;
+exports.verifyManifest = verifyManifest;
+/**
+ * ed25519 manifest signing + verification.
+ *
+ * The signature covers the JCS-canonical bytes of the manifest with
+ * `signing.signature` blanked to "". Node's native crypto handles ed25519
+ * (algorithm = null), so no third-party crypto dependency.
+ */
+const node_crypto_1 = require("node:crypto");
+const jcs_1 = require("./jcs");
+/** The exact bytes that get signed: JCS(manifest with signing.signature=""). */
+function signingBytes(manifest) {
+    const clone = JSON.parse(JSON.stringify(manifest));
+    clone.signing = { ...clone.signing, signature: '' };
+    return Buffer.from((0, jcs_1.canonicalize)(clone), 'utf8');
+}
+function toPrivateKey(key) {
+    return key instanceof node_crypto_1.KeyObject ? key : (0, node_crypto_1.createPrivateKey)(key);
+}
+function toPublicKey(key) {
+    return key instanceof node_crypto_1.KeyObject ? key : (0, node_crypto_1.createPublicKey)(key);
+}
+/** Sign in place: sets manifest.signing.signature (base64) and returns the manifest. */
+function signManifest(manifest, privateKey) {
+    const sig = (0, node_crypto_1.sign)(null, signingBytes(manifest), toPrivateKey(privateKey));
+    manifest.signing.signature = sig.toString('base64');
+    return manifest;
+}
+/** Verify the embedded signature against a public key. Returns true/false. */
+function verifyManifest(manifest, publicKey) {
+    const sigB64 = manifest.signing?.signature;
+    if (!sigB64)
+        return false;
+    try {
+        return (0, node_crypto_1.verify)(null, signingBytes(manifest), toPublicKey(publicKey), Buffer.from(sigB64, 'base64'));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/slots/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Qualcomm UEFI A/B slot selection via GPT partition-entry attribute bits.
+ * Canonical home (shared by particle-cli and the on-device OTA service).
+ *
+ *   bits 48-49  PRIORITY     (higher preferred; 0 = not selected by priority)
+ *   bit  50     ACTIVE       (slot the loader currently selects)
+ *   bits 51-53  RETRY/tries  (decremented per boot; 0 + !success => give up)
+ *   bit  54     SUCCESS      (booted OK; commit)
+ *   bit  55     UNBOOTABLE   (never select)
+ *
+ * NOTE: confirm exact positions vs the BP QcomPkg/.../PartitionTableUpdate.h
+ * before trusting on hardware — wrong bits brick slot selection. These match
+ * the standard Qualcomm boot_control layout. Pure BigInt helpers: unit-testable
+ * with no device.
+ */
+export declare const PRIORITY_SHIFT = 48n;
+export declare const PRIORITY_MASK = 3n;
+export declare const ACTIVE_BIT = 50n;
+export declare const RETRY_SHIFT = 51n;
+export declare const RETRY_MASK = 7n;
+export declare const SUCCESS_BIT = 54n;
+export declare const UNBOOTABLE_BIT = 55n;
+export declare const MAX_PRIORITY = 3;
+export declare const MAX_RETRY = 7;
+export type Slot = 'a' | 'b';
+export interface SlotState {
+    priority: number;
+    active: boolean;
+    retries: number;
+    success: boolean;
+    unbootable: boolean;
+}
+export declare function getSlotState(attr: bigint | number): SlotState;
+export declare function makeActivePending(attr: bigint | number, opts?: {
+    priority?: number;
+    retries?: number;
+}): bigint;
+export declare function makeInactiveFallback(attr: bigint | number, opts?: {
+    priority?: number;
+}): bigint;
+export declare function markSuccessful(attr: bigint | number, opts?: {
+    retries?: number;
+}): bigint;
+export declare function markUnbootable(attr: bigint | number): bigint;
+export declare function activeSlot(attrA: bigint | number, attrB: bigint | number): Slot;
+export interface SlotPart {
+    label: string;
+    lun: number;
+    slot: Slot;
+    attr: bigint | number;
+}
+export interface SlotChange {
+    label: string;
+    lun: number;
+    slot: Slot;
+    fromAttr: bigint;
+    toAttr: bigint;
+}
+export interface SlotPlan {
+    current: Slot;
+    target: Slot;
+    changes: SlotChange[];
+}
+export declare function planSlotSwitch(slotParts: SlotPart[], target: Slot): SlotPlan;