@aidc-toolkit/dev 0.9.16-beta → 0.9.17-beta

package/config/publish.json

@@ -0,0 +1,53 @@
+{
+  "organization": "aidc-toolkit",
+  "repositories": {
+    "dev": {
+      "dependencyType": "external",
+      "excludeFiles": [
+        "src/publish.ts",
+        "src/publish-internal.ts",
+        "src/publish-external.ts",
+        "config/publish.json",
+        "config/publish.secure.json"
+      ],
+      "lastExternalVersion": "0.9.16-beta",
+      "lastInternalPublished": "2025-03-02T19:42:30.219Z"
+    },
+    "core": {
+      "dependencyType": "external",
+      "lastExternalVersion": "0.9.16-beta",
+      "lastInternalPublished": "2025-03-02T19:46:27.439Z"
+    },
+    "utility": {
+      "dependencyType": "external",
+      "lastExternalVersion": "0.9.16-beta",
+      "lastInternalPublished": "2025-03-02T19:46:37.087Z"
+    },
+    "gs1": {
+      "dependencyType": "external",
+      "lastExternalVersion": "0.9.16-beta",
+      "lastInternalPublished": "2025-03-02T19:46:50.266Z"
+    },
+    "demo": {
+      "dependencyType": "none",
+      "lastExternalVersion": "0.9.16-beta"
+    },
+    "app-extension": {
+      "dependencyType": "internal",
+      "lastExternalVersion": "0.9.16-beta",
+      "internal": true,
+      "lastInternalPublished": "2025-03-02T19:47:50.192Z"
+    },
+    "app-generator": {
+      "dependencyType": "internal",
+      "lastExternalVersion": "0.9.16-beta",
+      "internal": true,
+      "lastInternalPublished": "2025-03-02T19:47:58.982Z"
+    },
+    "aidc-toolkit.github.io": {
+      "directory": "doc",
+      "dependencyType": "none",
+      "lastExternalVersion": "0.9.16-beta"
+    }
+  }
+}

package/dev.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/dist/index.d.ts

@@ -15,5 +15,5 @@
  * limitations under the License.
  */
 export * from "./eslint-config-template.js";
-export * from "./publish-dev.js";
+export * from "./utility.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,6BAA6B,CAAC;AAC5C,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -15,5 +15,5 @@
  * limitations under the License.
  */
 export * from "./eslint-config-template.js";
-export * from "./publish-dev.js";
+export * from "./utility.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,6BAA6B,CAAC;AAC5C,cAAc,cAAc,CAAC"}

package/dist/{command-util.d.ts → utility.d.ts}

@@ -1,3 +1,8 @@
+import { Logger } from "tslog";
+/**
+ * Logger with a default minimum level of Info.
+ */
+export declare const logger: Logger<unknown>;
 /**
  * Run a command and optionally capture its output.
  *
@@ -14,4 +19,4 @@
  * Output if captured or empty array if not.
  */
 export declare function run(captureOutput: boolean, command: string, ...args: string[]): string[];
-//# sourceMappingURL=command-util.d.ts.map
+//# sourceMappingURL=utility.d.ts.map

package/dist/utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../src/utility.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAS/B;;GAEG;AACH,eAAO,MAAM,MAAM,iBAEjB,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,CAAC,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA0BxF"}

package/dist/utility.js

@@ -0,0 +1,57 @@
+import { spawnSync } from "child_process";
+import { Logger } from "tslog";
+/**
+ * Log level.
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Silly"] = 0] = "Silly";
+    LogLevel[LogLevel["Trace"] = 1] = "Trace";
+    LogLevel[LogLevel["Debug"] = 2] = "Debug";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Warn"] = 4] = "Warn";
+    LogLevel[LogLevel["Error"] = 5] = "Error";
+    LogLevel[LogLevel["Fatal"] = 6] = "Fatal";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Logger with a default minimum level of Info.
+ */
+export const logger = new Logger({
+    minLevel: LogLevel.Info
+});
+/**
+ * Run a command and optionally capture its output.
+ *
+ * @param captureOutput
+ * If true, output is captured and returned.
+ *
+ * @param command
+ * Command to run.
+ *
+ * @param args
+ * Arguments to command.
+ *
+ * @returns
+ * Output if captured or empty array if not.
+ */
+export function run(captureOutput, command, ...args) {
+    logger.debug(`Running command "${command}" with arguments ${JSON.stringify(args)}.`);
+    const spawnResult = spawnSync(command, args, {
+        stdio: ["inherit", captureOutput ? "pipe" : "inherit", "inherit"]
+    });
+    if (spawnResult.error !== undefined) {
+        throw spawnResult.error;
+    }
+    if (spawnResult.status === null) {
+        throw new Error(`Terminated by signal ${spawnResult.signal}`);
+    }
+    if (spawnResult.status !== 0) {
+        throw new Error(`Failed with status ${spawnResult.status}`);
+    }
+    const output = captureOutput ? spawnResult.stdout.toString().split("\n").slice(0, -1) : [];
+    if (captureOutput) {
+        logger.debug(`Output is ${JSON.stringify(output)}.`);
+    }
+    return output;
+}
+//# sourceMappingURL=utility.js.map

package/dist/utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.js","sourceRoot":"","sources":["../src/utility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE/B;;GAEG;AACH,IAAK,QAEJ;AAFD,WAAK,QAAQ;IACT,yCAAK,CAAA;IAAE,yCAAK,CAAA;IAAE,yCAAK,CAAA;IAAE,uCAAI,CAAA;IAAE,uCAAI,CAAA;IAAE,yCAAK,CAAA;IAAE,yCAAK,CAAA;AACjD,CAAC,EAFI,QAAQ,KAAR,QAAQ,QAEZ;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC;IAC7B,QAAQ,EAAE,QAAQ,CAAC,IAAI;CAC1B,CAAC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,GAAG,CAAC,aAAsB,EAAE,OAAe,EAAE,GAAG,IAAc;IAC1E,MAAM,CAAC,KAAK,CAAC,oBAAoB,OAAO,oBAAoB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAErF,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE;QACzC,KAAK,EAAE,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC;KACpE,CAAC,CAAC;IAEH,IAAI,WAAW,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAClC,MAAM,WAAW,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,wBAAwB,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,sBAAsB,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAE3F,IAAI,aAAa,EAAE,CAAC;QAChB,MAAM,CAAC,KAAK,CAAC,aAAa,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,MAAM,CAAC;AAClB,CAAC"}

package/eslint.config.ts

@@ -1,3 +1,3 @@
-import { esLintConfigAIDCToolkit } from "./dist/index.js";
+import { esLintConfigAIDCToolkit } from "./dist";
 
 export default esLintConfigAIDCToolkit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aidc-toolkit/dev",
-  "version": "0.9.16-beta",
+  "version": "0.9.17-beta",
   "description": "Shared development artefacts for AIDC Toolkit",
   "type": "module",
   "main": "dist/index.js",
@@ -25,11 +25,8 @@
     "build:dev": "npm run build:core -- tsconfig-build-dev-local.json",
     "build:release": "npm run build:core -- tsconfig-build-local.json",
     "build:doc": "npm run build:dev",
-    "publish-dev": "bin/publish-dev-local",
-    "release": "tsx src/release.ts"
-  },
-  "bin": {
-    "publish-dev": "bin/publish-dev"
+    "publish-internal": "tsx src/publish-internal.ts",
+    "publish-external": "tsx src/publish-external.ts"
   },
   "devDependencies": {
     "copy-files-from-to": "^3.12.1"
@@ -45,6 +42,7 @@
     "octokit": "^4.1.2",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
+    "tslog": "^4.9.3",
     "tsx": "^4.19.3",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.25.0",

package/src/index.ts

@@ -15,4 +15,4 @@
  * limitations under the License.
  */
 export * from "./eslint-config-template.js";
-export * from "./publish-dev.js";
+export * from "./utility.js";

package/src/publish-external.ts

@@ -0,0 +1,332 @@
+import * as fs from "fs";
+import * as path from "node:path";
+import * as util from "node:util";
+import { Octokit } from "octokit";
+import { parse as yamlParse } from "yaml";
+import {
+    anyChanges,
+    configuration,
+    organizationRepository, type PackageConfiguration,
+    publishRepositories,
+    type Repository,
+    saveConfiguration,
+    secureConfiguration
+} from "./publish";
+import { logger, run } from "./utility.js";
+
+/**
+ * Configuration layout of release.yml workflow (relevant attributes only).
+ */
+interface WorkflowConfiguration {
+    /**
+     * Workflow name.
+     */
+    name: string;
+
+    /**
+     * Workflow trigger.
+     */
+    on: {
+        /**
+         * Push trigger.
+         */
+        push?: {
+            /**
+             * Push branches.
+             */
+            branches?: string[];
+        };
+
+        /**
+         * Release trigger.
+         */
+        release?: {
+            /**
+             * Release types.
+             */
+            types?: string[];
+        };
+    };
+}
+
+/**
+ * Supported steps.
+ */
+type Step =
+    "skipped" | "install" | "build" | "commit" | "tag" | "push" | "workflow (push)" | "release" | "workflow (release)" | "restore alpha" | "complete";
+
+/**
+ * Execute a step.
+ *
+ * @param repository
+ * Repository.
+ *
+ * @param step
+ * State at which step takes place.
+ *
+ * @param callback
+ * Callback to execute step.
+ *
+ * @returns
+ * Promise.
+ */
+async function runStep(repository: Repository, step: Step, callback: () => (void | Promise<void>)): Promise<void> {
+    if (repository.publishExternalStep === undefined || repository.publishExternalStep === step) {
+        logger.debug(`Running step ${step}`);
+
+        repository.publishExternalStep = step;
+
+        try {
+            const result = callback();
+
+            if (result instanceof Promise) {
+                await result;
+            }
+
+            repository.publishExternalStep = undefined;
+        } finally {
+            saveConfiguration();
+        }
+    } else {
+        logger.debug(`Skipping step ${step}`);
+    }
+}
+
+/**
+ * Update dependencies from the organization.
+ *
+ * @param restoreAlpha
+ * If true, restore "alpha" as the version for development.
+ *
+ * @param development
+ * True if updating development dependencies.
+ *
+ * @param internal
+ * True if the package is for internal use only and its version should not be used in dependencies.
+ *
+ * @param dependencies
+ * Dependencies.
+ *
+ * @returns
+ * True if any dependencies were updated.
+ */
+function updateDependencies(restoreAlpha: boolean, development: boolean, internal: boolean | undefined, dependencies: Record<string, string> | undefined): boolean {
+    let anyUpdated = false;
+
+    if (dependencies !== undefined) {
+        // eslint-disable-next-line guard-for-in -- Dependency record type is shallow.
+        for (const dependency in dependencies) {
+            const dependencyRepositoryName = organizationRepository(dependency);
+
+            if (dependencyRepositoryName !== null) {
+                const dependencyRepository = configuration.repositories[dependencyRepositoryName];
+
+                // Set to explicit version for external dependency.
+                if (dependencyRepository.dependencyType === "external") {
+                    dependencies[dependency] = !restoreAlpha ? `^${dependencyRepository.lastExternalVersion}` : "alpha";
+                    anyUpdated = true;
+                } else if (!restoreAlpha && !development && internal !== true) {
+                    throw new Error("Internal dependency specified for external package");
+                }
+            }
+        }
+    }
+
+    return anyUpdated;
+}
+
+const octokit = new Octokit({
+    auth: secureConfiguration.token,
+    userAgent: `${configuration.organization} release`
+});
+
+await publishRepositories(async (name, repository) => {
+    // Repository must be on main branch.
+    if (run(true, "git", "branch", "--show-current")[0] !== "main") {
+        throw new Error("Repository is not on main branch");
+    }
+
+    const packageConfigurationPath = "package.json";
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Package configuration format is known.
+    const packageConfiguration: PackageConfiguration = JSON.parse(fs.readFileSync(packageConfigurationPath).toString());
+
+    let publish: boolean;
+
+    if (repository.publishExternalStep === undefined) {
+        publish = anyChanges(repository, true);
+    } else {
+        publish = true;
+    }
+
+    if (packageConfiguration.version !== repository.lastExternalVersion) {
+        // Package version has already been updated, either manually or by previous failed run.
+        publish = true;
+    } else if (publish) {
+        const packageVersionSplits = packageConfiguration.version.split("-");
+
+        // Extract semantic version and pre-release identifier.
+        const semanticVersion = packageVersionSplits[0];
+        const preReleaseIdentifier = packageVersionSplits.length !== 1 ? `-${packageVersionSplits[1]}` : "";
+
+        // Parse semantic version into its components.
+        const [majorVersion, minorVersion, patchVersion] = semanticVersion.split(".").map(versionString => Number(versionString));
+
+        // Increment patch version number.
+        packageConfiguration.version = `${majorVersion}.${minorVersion}.${patchVersion + 1}${preReleaseIdentifier}`;
+    }
+
+    const tag = `v${packageConfiguration.version}`;
+
+    const octokitParameterBase = {
+        owner: configuration.organization,
+        repo: name
+    };
+
+    const internal = repository.dependencyType === "internal";
+
+    if (publish) {
+        if (repository.publishExternalStep === undefined) {
+            updateDependencies(false, true, internal, packageConfiguration.devDependencies);
+            updateDependencies(false, false, internal, packageConfiguration.dependencies);
+
+            fs.writeFileSync(packageConfigurationPath, `${JSON.stringify(packageConfiguration, null, 2)}\n`);
+        } else {
+            logger.debug(`Repository failed at step ${repository.publishExternalStep} on prior run`);
+        }
+
+        const workflowsPath = ".github/workflows/";
+
+        let hasPushWorkflow = false;
+        let hasReleaseWorkflow = false;
+
+        if (fs.existsSync(workflowsPath)) {
+            logger.debug("Checking workflows");
+
+            for (const workflowFile of fs.readdirSync(workflowsPath).filter(workflowFile => workflowFile.endsWith(".yml"))) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Workflow configuration format is known.
+                const workflowOn = (yamlParse(fs.readFileSync(path.resolve(workflowsPath, workflowFile)).toString()) as WorkflowConfiguration).on;
+
+                if (workflowOn.push !== undefined && (workflowOn.push.branches === undefined || workflowOn.push.branches.includes("main"))) {
+                    logger.debug("Repository has push workflow");
+
+                    hasPushWorkflow = true;
+                }
+
+                if (workflowOn.release !== undefined && (workflowOn.release.types === undefined || workflowOn.release.types.includes("published"))) {
+                    logger.debug("Repository has release workflow");
+
+                    hasReleaseWorkflow = true;
+                }
+            }
+        }
+
+        /**
+         * Validate the workflow by waiting for it to complete.
+         */
+        async function validateWorkflow(): Promise<void> {
+            const commitSHA = run(true, "git", "rev-parse", "HEAD")[0];
+
+            let completed = false;
+            let queryCount = 0;
+            let workflowRunID = -1;
+
+            do {
+                await util.promisify(setTimeout)(2000);
+
+                const response = await octokit.rest.actions.listWorkflowRunsForRepo({
+                    ...octokitParameterBase,
+                    head_sha: commitSHA
+                });
+
+                for (const workflowRun of response.data.workflow_runs) {
+                    if (workflowRun.status !== "completed") {
+                        if (workflowRun.id === workflowRunID) {
+                            process.stdout.write(".");
+                        } else if (workflowRunID === -1) {
+                            workflowRunID = workflowRun.id;
+
+                            logger.info(`Workflow run ID ${workflowRunID}`);
+                        } else {
+                            throw new Error(`Parallel workflow runs for SHA ${commitSHA}`);
+                        }
+                    } else if (workflowRun.id === workflowRunID) {
+                        process.stdout.write("\n");
+
+                        if (workflowRun.conclusion !== "success") {
+                            throw new Error(`Workflow ${workflowRun.conclusion}`);
+                        }
+
+                        completed = true;
+                    }
+                }
+
+                // Abort if workflow run not started after 10 queries.
+                if (++queryCount === 10 && workflowRunID === -1) {
+                    throw new Error(`Workflow run not started for SHA ${commitSHA}`);
+                }
+            } while (!completed);
+        }
+
+        await runStep(repository, "install", () => {
+            run(false, "npm", "install");
+        });
+
+        await runStep(repository, "build", () => {
+            run(false, "npm", "run", "build", "--if-present");
+        });
+
+        await runStep(repository, "commit", () => {
+            run(false, "git", "commit", "--all", `--message=Updated to version ${packageConfiguration.version}.`);
+        });
+
+        await runStep(repository, "tag", () => {
+            run(false, "git", "tag", tag);
+        });
+
+        await runStep(repository, "push", () => {
+            run(false, "git", "push", "--atomic", "origin", "main", tag);
+        });
+
+        if (hasPushWorkflow) {
+            await runStep(repository, "workflow (push)", async () => {
+                await validateWorkflow();
+            });
+        }
+
+        await runStep(repository, "release", async () => {
+            const versionSplit = packageConfiguration.version.split("-");
+            const prerelease = versionSplit.length !== 1;
+
+            await octokit.rest.repos.createRelease({
+                ...octokitParameterBase,
+                tag_name: tag,
+                name: `${prerelease ? `${versionSplit[1].substring(0, 1).toUpperCase()}${versionSplit[1].substring(1)}` : "Production"} release ${versionSplit[0]}`,
+                prerelease
+            });
+        });
+
+        if (hasReleaseWorkflow) {
+            await runStep(repository, "workflow (release)", async () => {
+                await validateWorkflow();
+            });
+        }
+
+        await runStep(repository, "restore alpha", () => {
+            // Restore dependencies to "alpha" version for development.
+            const devDependenciesUpdated = updateDependencies(true, true, internal, packageConfiguration.devDependencies);
+            const dependenciesUpdated = updateDependencies(true, false, internal, packageConfiguration.dependencies);
+
+            if (devDependenciesUpdated || dependenciesUpdated) {
+                fs.writeFileSync(packageConfigurationPath, `${JSON.stringify(packageConfiguration, null, 2)}\n`);
+                run(false, "git", "commit", "--all", "--message=Restored alpha version.");
+            }
+        });
+
+        repository.lastExternalPublished = new Date().toISOString();
+        repository.lastExternalVersion = packageConfiguration.version;
+        repository.publishExternalStep = undefined;
+    }
+}).catch((e: unknown) => {
+    logger.error(e);
+});

package/src/publish-internal.ts

@@ -0,0 +1,111 @@
+import * as fs from "fs";
+import { anyChanges, organizationRepository, type PackageConfiguration, publishRepositories } from "./publish";
+import { logger, run } from "./utility.js";
+
+/**
+ * Check dependencies for belonging to the organization; if not, check for updates and log a message if an update is
+ * available.
+ *
+ * @param dependencies
+ * Dependencies.
+ *
+ * @returns
+ * Dependencies belonging to the organization.
+ */
+function checkDependencyUpdates(dependencies?: Record<string, string>): string[] {
+    const organizationDependencies = [];
+
+    if (dependencies !== undefined) {
+        for (const [dependency, version] of Object.entries(dependencies)) {
+            if (organizationRepository(dependency) !== null) {
+                organizationDependencies.push(dependency);
+            } else if (version.startsWith("^")) {
+                const [latestVersion] = run(true, "npm", "view", dependency, "version");
+
+                if (latestVersion !== version.substring(1)) {
+                    logger.info(`Dependency ${dependency}@${version} pending update to version ${latestVersion}.`);
+                }
+            }
+        }
+    }
+
+    return organizationDependencies;
+}
+
+/**
+ * Convert a number to a zero-padded string.
+ *
+ * @param n
+ * Number.
+ *
+ * @param length
+ * Length of required string.
+ *
+ * @returns
+ * Zero-padded string.
+ */
+function zeroPadded(n: number, length: number): string {
+    return `${"0".repeat(length - 1)}${n}`.slice(-length);
+}
+
+await publishRepositories((_name, repository) => {
+    const packageConfigurationPath = "package.json";
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Package configuration format is known.
+    const packageConfiguration: PackageConfiguration = JSON.parse(fs.readFileSync(packageConfigurationPath).toString());
+
+    // Check dependency updates, even if there are no changes.
+    const organizationDependencies = [...checkDependencyUpdates(packageConfiguration.devDependencies), ...checkDependencyUpdates(packageConfiguration.dependencies)];
+
+    if (organizationDependencies.length !== 0) {
+        logger.debug(`Updating organization dependencies ${JSON.stringify(organizationDependencies)}`);
+
+        run(false, "npm", "update", ...organizationDependencies);
+    }
+
+    // Nothing further required if this repository is not a dependency.
+    if (repository.dependencyType !== "none" && anyChanges(repository, false)) {
+        const backupPackageConfigurationPath = ".package.json";
+
+        // Backup the package configuration file.
+        fs.renameSync(packageConfigurationPath, backupPackageConfigurationPath);
+
+        try {
+            const now = new Date();
+
+            // Strip pre-release identifier if any.
+            const [semanticVersion] = packageConfiguration.version.split("-");
+
+            // Parse semantic version into its components.
+            const [majorVersion, minorVersion, patchVersion] = semanticVersion.split(".").map(versionString => Number(versionString));
+
+            // Set version to alpha version with incremental patch version number.
+            packageConfiguration.version = `${majorVersion}.${minorVersion}.${patchVersion + 1}-alpha.${now.getFullYear()}${zeroPadded(now.getMonth() + 1, 2)}${zeroPadded(now.getDate(), 2)}${zeroPadded(now.getHours(), 2)}${zeroPadded(now.getMinutes(), 2)}`;
+
+            // Update the package configuration for the build.
+            fs.writeFileSync(packageConfigurationPath, `${JSON.stringify(packageConfiguration, null, 2)}\n`);
+
+            // Run development build.
+            run(false, "npm", "run", "build:dev");
+
+            // Publish to development npm registry.
+            run(false, "npm", "publish", "--tag", "alpha");
+
+            // Unpublish all prior alpha versions.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Output is a JSON array.
+            for (const version of JSON.parse(run(true, "npm", "view", packageConfiguration.name, "versions", "--json").join("\n")) as string[]) {
+                if (/^[0-9]+.[0-9]+.[0-9]+-alpha.[0-9]+$/.test(version) && version !== packageConfiguration.version) {
+                    run(false, "npm", "unpublish", `${packageConfiguration.name}@${version}`);
+                }
+            }
+
+            repository.lastInternalPublished = now.toISOString();
+        } finally {
+            // Restore the package configuration file.
+            fs.rmSync(packageConfigurationPath);
+            fs.renameSync(backupPackageConfigurationPath, packageConfigurationPath);
+        }
+    }
+}).catch((e: unknown) => {
+    logger.error(e);
+});