ticbuild 1.0.0

package/dist/backend/manifestTypes.d.ts

@@ -0,0 +1,454 @@
+import { OptimizationRuleOptions } from "../utils/lua/lua_processor";
+import { SourceEncodingKey } from "../utils/encoding/codecRegistry";
+import { Tic80CartChunkTypeKey } from "../utils/tic80/tic80";
+export declare const kImportKind: {
+    readonly $key: "binary" | "LuaCode" | "Tic80Cartridge" | "text";
+    readonly $value: "binary" | "LuaCode" | "Tic80Cartridge" | "text";
+    readonly $info: ({
+        key: "binary";
+    } & {
+        readonly value: "binary";
+    }) | ({
+        key: "LuaCode";
+    } & {
+        readonly value: "LuaCode";
+    }) | ({
+        key: "Tic80Cartridge";
+    } & {
+        readonly value: "Tic80Cartridge";
+    }) | ({
+        key: "text";
+    } & {
+        readonly value: "text";
+    });
+    readonly valueByKey: {
+        readonly binary: "binary";
+        readonly LuaCode: "LuaCode";
+        readonly Tic80Cartridge: "Tic80Cartridge";
+        readonly text: "text";
+    };
+    readonly infoByKey: {
+        readonly binary: {
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        };
+        readonly LuaCode: {
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        };
+        readonly Tic80Cartridge: {
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        };
+        readonly text: {
+            key: "text";
+        } & {
+            readonly value: "text";
+        };
+    };
+    readonly key: {
+        readonly binary: "binary";
+        readonly LuaCode: "LuaCode";
+        readonly Tic80Cartridge: "Tic80Cartridge";
+        readonly text: "text";
+    };
+    readonly byKey: {
+        readonly LuaCode: {
+            readonly value: "LuaCode";
+        };
+        readonly Tic80Cartridge: {
+            readonly value: "Tic80Cartridge";
+        };
+        readonly binary: {
+            readonly value: "binary";
+        };
+        readonly text: {
+            readonly value: "text";
+        };
+    };
+    readonly infoByValue: Map<"binary" | "LuaCode" | "Tic80Cartridge" | "text", ({
+        key: "binary";
+    } & {
+        readonly value: "binary";
+    }) | ({
+        key: "LuaCode";
+    } & {
+        readonly value: "LuaCode";
+    }) | ({
+        key: "Tic80Cartridge";
+    } & {
+        readonly value: "Tic80Cartridge";
+    }) | ({
+        key: "text";
+    } & {
+        readonly value: "text";
+    })>;
+    readonly keyByValue: Map<"binary" | "LuaCode" | "Tic80Cartridge" | "text", "binary" | "LuaCode" | "Tic80Cartridge" | "text">;
+    readonly keys: ["binary" | "LuaCode" | "Tic80Cartridge" | "text", ...("binary" | "LuaCode" | "Tic80Cartridge" | "text")[]];
+    readonly values: ("binary" | "LuaCode" | "Tic80Cartridge" | "text")[];
+    readonly infos: (({
+        key: "binary";
+    } & {
+        readonly value: "binary";
+    }) | ({
+        key: "LuaCode";
+    } & {
+        readonly value: "LuaCode";
+    }) | ({
+        key: "Tic80Cartridge";
+    } & {
+        readonly value: "Tic80Cartridge";
+    }) | ({
+        key: "text";
+    } & {
+        readonly value: "text";
+    }))[];
+    readonly valuesSet: Set<"binary" | "LuaCode" | "Tic80Cartridge" | "text">;
+    readonly keysSet: Set<"binary" | "LuaCode" | "Tic80Cartridge" | "text">;
+    readonly isValidKey: (k: any) => k is "binary" | "LuaCode" | "Tic80Cartridge" | "text";
+    readonly coerceByKey: {
+        (k: any): (({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        })) | undefined;
+        (k: any, fallbackKey: "binary" | "LuaCode" | "Tic80Cartridge" | "text"): ({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        });
+    };
+    readonly coerceByValue: {
+        (v: any): (({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        })) | undefined;
+        (v: any, fallbackKey: "binary" | "LuaCode" | "Tic80Cartridge" | "text"): ({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        });
+    };
+    readonly coerceByValueOrKey: {
+        (vk: any): (({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        })) | undefined;
+        (vk: any, fallbackKey: "binary" | "LuaCode" | "Tic80Cartridge" | "text"): ({
+            key: "binary";
+        } & {
+            readonly value: "binary";
+        }) | ({
+            key: "LuaCode";
+        } & {
+            readonly value: "LuaCode";
+        }) | ({
+            key: "Tic80Cartridge";
+        } & {
+            readonly value: "Tic80Cartridge";
+        }) | ({
+            key: "text";
+        } & {
+            readonly value: "text";
+        });
+    };
+};
+export type ImportKindKey = typeof kImportKind.$key;
+export interface ProjectConfig {
+    name: string;
+    includeDirs?: string[];
+    importDirs?: string[];
+    binDir: string;
+    objDir: string;
+    outputCartName: string;
+}
+export interface ImportDefinition {
+    name: string;
+    path?: string;
+    kind?: ImportKindKey;
+    chunks?: Tic80CartChunkTypeKey[];
+    sourceEncoding?: SourceEncodingKey;
+    value?: string;
+}
+export interface AssetReference {
+    import: string;
+    chunks?: Tic80CartChunkTypeKey[];
+}
+export interface AssemblyBlock {
+    chunks?: Tic80CartChunkTypeKey[];
+    bank?: number;
+    asset: string | AssetReference;
+    code?: CodeAssemblyOptions;
+}
+export type CodeAssemblyOptions = {
+    emitGlobals?: boolean;
+};
+export type LuaMinificationConfig = Partial<OptimizationRuleOptions>;
+export interface LuaAssemblyConfig {
+    minify?: boolean;
+    minification?: LuaMinificationConfig;
+    globals?: Record<string, string | number | boolean>;
+}
+export interface AssemblyConfig {
+    lua?: LuaAssemblyConfig;
+    blocks: AssemblyBlock[];
+}
+export interface BuildConfiguration {
+    project?: Partial<ProjectConfig>;
+    variables?: Record<string, string>;
+    assembly?: Partial<AssemblyConfig>;
+}
+export interface Manifest {
+    project: ProjectConfig;
+    variables?: Record<string, string>;
+    imports: ImportDefinition[];
+    assembly: AssemblyConfig;
+    buildConfigurations?: Record<string, BuildConfiguration>;
+}
+export type VariableInfo = {
+    name: string;
+    rawValue: string;
+    resolvedValue: string;
+};
+export type ResolvedManifest = {
+    manifest: Manifest;
+    selectedBuildConfig?: string | undefined;
+    variables: Map<string, VariableInfo>;
+};
+export declare const kCommonVariables: {
+    readonly $key: "projectDir" | "manifestPath" | "outputCartName";
+    readonly $value: "project.projectDir" | "project.manifestPath" | "project.outputCartName";
+    readonly $info: ({
+        key: "projectDir";
+    } & {
+        readonly value: "project.projectDir";
+    }) | ({
+        key: "manifestPath";
+    } & {
+        readonly value: "project.manifestPath";
+    }) | ({
+        key: "outputCartName";
+    } & {
+        readonly value: "project.outputCartName";
+    });
+    readonly valueByKey: {
+        readonly projectDir: "project.projectDir";
+        readonly manifestPath: "project.manifestPath";
+        readonly outputCartName: "project.outputCartName";
+    };
+    readonly infoByKey: {
+        readonly projectDir: {
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        };
+        readonly manifestPath: {
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        };
+        readonly outputCartName: {
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        };
+    };
+    readonly key: {
+        readonly projectDir: "projectDir";
+        readonly manifestPath: "manifestPath";
+        readonly outputCartName: "outputCartName";
+    };
+    readonly byKey: {
+        readonly projectDir: {
+            readonly value: "project.projectDir";
+        };
+        readonly manifestPath: {
+            readonly value: "project.manifestPath";
+        };
+        readonly outputCartName: {
+            readonly value: "project.outputCartName";
+        };
+    };
+    readonly infoByValue: Map<"project.projectDir" | "project.manifestPath" | "project.outputCartName", ({
+        key: "projectDir";
+    } & {
+        readonly value: "project.projectDir";
+    }) | ({
+        key: "manifestPath";
+    } & {
+        readonly value: "project.manifestPath";
+    }) | ({
+        key: "outputCartName";
+    } & {
+        readonly value: "project.outputCartName";
+    })>;
+    readonly keyByValue: Map<"project.projectDir" | "project.manifestPath" | "project.outputCartName", "projectDir" | "manifestPath" | "outputCartName">;
+    readonly keys: ["projectDir" | "manifestPath" | "outputCartName", ...("projectDir" | "manifestPath" | "outputCartName")[]];
+    readonly values: ("project.projectDir" | "project.manifestPath" | "project.outputCartName")[];
+    readonly infos: (({
+        key: "projectDir";
+    } & {
+        readonly value: "project.projectDir";
+    }) | ({
+        key: "manifestPath";
+    } & {
+        readonly value: "project.manifestPath";
+    }) | ({
+        key: "outputCartName";
+    } & {
+        readonly value: "project.outputCartName";
+    }))[];
+    readonly valuesSet: Set<"project.projectDir" | "project.manifestPath" | "project.outputCartName">;
+    readonly keysSet: Set<"projectDir" | "manifestPath" | "outputCartName">;
+    readonly isValidKey: (k: any) => k is "projectDir" | "manifestPath" | "outputCartName";
+    readonly coerceByKey: {
+        (k: any): (({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        })) | undefined;
+        (k: any, fallbackKey: "projectDir" | "manifestPath" | "outputCartName"): ({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        });
+    };
+    readonly coerceByValue: {
+        (v: any): (({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        })) | undefined;
+        (v: any, fallbackKey: "projectDir" | "manifestPath" | "outputCartName"): ({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        });
+    };
+    readonly coerceByValueOrKey: {
+        (vk: any): (({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        })) | undefined;
+        (vk: any, fallbackKey: "projectDir" | "manifestPath" | "outputCartName"): ({
+            key: "projectDir";
+        } & {
+            readonly value: "project.projectDir";
+        }) | ({
+            key: "manifestPath";
+        } & {
+            readonly value: "project.manifestPath";
+        }) | ({
+            key: "outputCartName";
+        } & {
+            readonly value: "project.outputCartName";
+        });
+    };
+};
+//# sourceMappingURL=manifestTypes.d.ts.map

package/dist/backend/manifestTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifestTypes.d.ts","sourceRoot":"","sources":["../../src/backend/manifestTypes.ts"],"names":[],"mappings":"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"}

package/dist/backend/manifestTypes.js

@@ -0,0 +1,28 @@
+"use strict";
+// TODO: make this structured to actually run some rules.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kCommonVariables = exports.kImportKind = void 0;
+const enum_1 = require("../utils/enum");
+// TIC-80 cartridge chunk types.
+// https://github.com/nesbox/TIC-80/wiki/.tic-File-Format
+// importers... maybe an enum later?
+exports.kImportKind = (0, enum_1.defineEnum)({
+    LuaCode: {
+        value: "LuaCode",
+    },
+    Tic80Cartridge: {
+        value: "Tic80Cartridge",
+    },
+    binary: {
+        value: "binary",
+    },
+    text: {
+        value: "text",
+    },
+}); // "LuaCode" | "Tic80Cartridge";
+exports.kCommonVariables = (0, enum_1.defineEnum)({
+    projectDir: { value: "project.projectDir" },
+    manifestPath: { value: "project.manifestPath" },
+    outputCartName: { value: "project.outputCartName" },
+});
+//# sourceMappingURL=manifestTypes.js.map

package/dist/backend/manifestTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifestTypes.js","sourceRoot":"","sources":["../../src/backend/manifestTypes.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAEzD,wCAA2C;AAK3C,gCAAgC;AAChC,yDAAyD;AAEzD,oCAAoC;AACvB,QAAA,WAAW,GAAG,IAAA,iBAAU,EAAC;IACpC,OAAO,EAAE;QACP,KAAK,EAAE,SAAS;KACjB;IACD,cAAc,EAAE;QACd,KAAK,EAAE,gBAAgB;KACxB;IACD,MAAM,EAAE;QACN,KAAK,EAAE,QAAQ;KAChB;IACD,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM;KACd;CACO,CAAC,CAAC,CAAC,gCAAgC;AAgFhC,QAAA,gBAAgB,GAAG,IAAA,iBAAU,EAAC;IACzC,UAAU,EAAE,EAAE,KAAK,EAAE,oBAAoB,EAAE;IAC3C,YAAY,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE;IAC/C,cAAc,EAAE,EAAE,KAAK,EAAE,wBAAwB,EAAE;CAC3C,CAAC,CAAC"}

package/dist/backend/project.d.ts

@@ -0,0 +1,24 @@
+import { Tic80CartChunk } from "../utils/tic80/tic80";
+import { ResourceManager } from "./ImportedResourceTypes";
+import { TicbuildProjectCore } from "./projectCore";
+export type TicbuildProjectLoadOptions = {
+    manifestPath?: string | undefined;
+    buildConfigName?: string | undefined;
+    overrideVariables?: Record<string, string>;
+};
+export type AssembleOutputResult = {
+    output: Uint8Array;
+    chunks: Tic80CartChunk[];
+};
+export declare class TicbuildProject {
+    unresolvedCore: TicbuildProjectCore;
+    resolvedCore: TicbuildProjectCore;
+    resourceMgr: ResourceManager | undefined;
+    static loadFromManifest(options?: TicbuildProjectLoadOptions): TicbuildProject;
+    private constructor();
+    private resolveManifest;
+    loadImports(): Promise<void>;
+    private assembleBlock;
+    assembleOutput(): Promise<AssembleOutputResult>;
+}
+//# sourceMappingURL=project.d.ts.map

package/dist/backend/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/backend/project.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI1D,OAAO,EAAoE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEtH,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAGF,qBAAa,eAAe;IAC1B,cAAc,EAAE,mBAAmB,CAAC;IAQpC,YAAY,EAAE,mBAAmB,CAAC;IAElC,WAAW,EAAE,eAAe,GAAG,SAAS,CAAC;IAEzC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,eAAe;IAU9E,OAAO;IAwBP,OAAO,CAAC,eAAe;IAuEjB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;YAKpB,aAAa;IA+CrB,cAAc,IAAI,OAAO,CAAC,oBAAoB,CAAC;CA0BtD"}

package/dist/backend/project.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicbuildProject = void 0;
+const errorHandling_1 = require("../utils/errorHandling");
+const cartWriter_1 = require("../utils/tic80/cartWriter");
+const tic80_1 = require("../utils/tic80/tic80");
+const utils_1 = require("../utils/utils");
+const importResources_1 = require("./importResources");
+const manifestLoader_1 = require("./manifestLoader");
+const manifestTypes_1 = require("./manifestTypes");
+const projectCore_1 = require("./projectCore");
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class TicbuildProject {
+    static loadFromManifest(options) {
+        const loadedManifest = (0, manifestLoader_1.resolveAndLoadManifest)(options?.manifestPath);
+        return new TicbuildProject(loadedManifest.manifest, //
+        loadedManifest.filePath, loadedManifest.projectDir, options);
+    }
+    constructor(manifest, manifestPath, projectDir, options) {
+        this.unresolvedCore = new projectCore_1.TicbuildProjectCore({
+            manifest,
+            manifestPath,
+            projectDir,
+            buildConfigName: options?.buildConfigName,
+            overrideVariables: options?.overrideVariables,
+        });
+        const resolvedManifest = this.resolveManifest(manifestPath, projectDir, options);
+        this.resolvedCore = new projectCore_1.TicbuildProjectCore({
+            manifest: resolvedManifest.manifest,
+            manifestPath,
+            projectDir,
+            buildConfigName: options?.buildConfigName,
+            overrideVariables: options?.overrideVariables,
+        });
+    }
+    resolveManifest(manifestPath, projectDir, options) {
+        // avoid mutations
+        const resolved = this.unresolvedCore.clone().manifest;
+        // in this process, avoid handling of specific fields; general behaviors are preferred
+        // for maintainability.
+        if (options?.buildConfigName) {
+            const buildConfig = this.unresolvedCore.manifest.buildConfigurations?.[options.buildConfigName];
+            if (!buildConfig) {
+                throw new Error(`Build configuration not found: ${options.buildConfigName}`);
+            }
+            // for every leaf in project settings, override / add to resolved manifest
+            // for example { project: { binDir: "..." } } overrides resolved.project.binDir
+            // arrays are considered a leaf value. e.g., { project: { includeDirs: [...] } } substitutes the entire array.
+            // we want to avoid handling specific cases; we want generic merge/override behavior.
+            (0, utils_1.deepMergeObjects)(resolved, buildConfig);
+            // that makes it theoretically possible to override the assembly.blocks array too,
+            // so we need to canonicalize asset references again after applying the build config.
+        }
+        // there's a special case to handle:
+        // assembly.blocks[].asset supports a shorthand form.
+        // canonical form:
+        //   "asset": { "import": "music-imported-cart", "chunks": ["MUSIC_WAVEFORMS"] },
+        // shorthand:
+        //   "asset": "import:music-imported-cart:MUSIC_WAVEFORMS",
+        for (const block of resolved.assembly.blocks) {
+            block.asset = (0, projectCore_1.canonicalizeAssetImport)(block.asset);
+        }
+        const calculatedVars = (0, projectCore_1.calculateVars)(resolved, manifestPath, projectDir, options?.overrideVariables, options?.buildConfigName);
+        // ensure all imports have "kind" -- deduce if missing.
+        for (const importDef of resolved.imports) {
+            if (!importDef.kind) {
+                if (!importDef.path) {
+                    throw new Error(`Import ${importDef.name} must specify kind when no path is provided`);
+                }
+                const deducedKind = (0, projectCore_1.deduceImportKindFromPath)(importDef.path);
+                if (!deducedKind) {
+                    throw new Error(`Could not deduce import kind from path: ${importDef.path} (please specify explicitly in manifest)`);
+                }
+                const coerced = manifestTypes_1.kImportKind.coerceByKey(deducedKind);
+                if (!coerced) {
+                    throw new Error(`Deduced import kind is invalid: ${deducedKind} (please specify explicitly in manifest)`);
+                }
+                importDef.kind = coerced.key;
+            }
+        }
+        return {
+            manifest: resolved, //
+            variables: calculatedVars,
+        };
+    }
+    async loadImports() {
+        this.resourceMgr = await (0, importResources_1.loadAllImports)(this.resolvedCore);
+    }
+    // takse a block def and returns the multiple chunks it may produce.
+    async assembleBlock(block) {
+        (0, errorHandling_1.assert)(!!this.resourceMgr);
+        // for binary copy, just retrieve the asset data from the resource manager.
+        const assetRef = block.asset;
+        const resource = this.resourceMgr.items.get(assetRef.import);
+        if (!resource) {
+            throw new Error(`Imported resource not found: ${assetRef.import}`);
+        }
+        const view = resource.getView(this.resolvedCore, block.chunks);
+        // extract the bins from the resource view and output as chunks.
+        const outputChunks = [];
+        const requestedChunks = block.chunks || view.getParallelChunkTypes();
+        const bank = block.bank ?? 0;
+        for (const chunkType of requestedChunks) {
+            const data = view.getDataForChunk(this.resolvedCore, chunkType, block.code);
+            if (chunkType === "CODE") {
+                const codeInfo = tic80_1.kTic80CartChunkTypes.byKey.CODE;
+                const maxChunkSize = codeInfo.sizePerBank;
+                if (data.length > maxChunkSize) {
+                    if (block.bank !== undefined) {
+                        // it's confusing what you mean if you specify a bank here.
+                        // exceeding 1 bank = auto-split code into auto banks.
+                        throw new Error(`CODE chunk exceeds ${maxChunkSize} bytes but bank was specified`);
+                    }
+                    const bankCount = Math.ceil(data.length / maxChunkSize);
+                    for (let i = 0; i < bankCount; i++) {
+                        const start = i * maxChunkSize;
+                        const end = Math.min(start + maxChunkSize, data.length);
+                        outputChunks.push({
+                            chunkType,
+                            bank: i,
+                            data: data.subarray(start, end),
+                        });
+                    }
+                    continue;
+                }
+            }
+            outputChunks.push({
+                chunkType,
+                bank,
+                data,
+            });
+        }
+        return outputChunks;
+    }
+    async assembleOutput() {
+        if (!this.resourceMgr) {
+            throw new Error("Resources not loaded. Call loadImports() before assembleOutput().");
+        }
+        const assembly = this.resolvedCore.manifest.assembly;
+        const tasks = [];
+        for (const block of assembly.blocks) {
+            // generate the binary output for each requested block.
+            tasks.push(this.assembleBlock(block));
+        }
+        // write the final output cartridge
+        const results = await Promise.all(tasks);
+        const finalChunks = [];
+        for (const chunkList of results) {
+            finalChunks.push(...chunkList);
+        }
+        // generate final tic80 cart binary
+        const output = await (0, cartWriter_1.AssembleTic80Cart)({
+            chunks: finalChunks,
+        });
+        return { output, chunks: finalChunks };
+    }
+}
+exports.TicbuildProject = TicbuildProject;
+//# sourceMappingURL=project.js.map