@flisk-sh/flisk 1.3.206 → 1.4.0

package/cli/dist/commands/up.js

@@ -12,8 +12,9 @@ import { STANDARD_PORTS } from "../utils/constants.js";
 import { getDeferredResourceNames, summarizeTiltBuildError } from "../utils/doctor-runtime.js";
 import { applyEnvFileSelection, assertEngineSupportsEnvFile, EnvFileError, envFileWarning, PROJECT_ENV_FILE_VAR, selectEnvFile, } from "../utils/env-selection.js";
 import { completeEnvFile } from "../utils/env-validator.js";
-import { errorFactories, getErrorMessage, handleTiltFailure, requireProjectRoot, runCommand, showError, showErrorAndExit, TdkError, withTiltCheck, } from "../utils/errors.js";
+import { errorFactories, FliskError, getErrorMessage, handleTiltFailure, requireProjectRoot, runCommand, showError, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { ensureSmokeRecordsIgnored } from "../utils/file-helpers.js";
+import { evaluateFliskVersionFloor } from "../utils/flisk-version.js";
 import { formatCount } from "../utils/formatting.js";
 import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "../utils/host-port-config.js";
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
@@ -30,7 +31,6 @@ import { appendHealthPath, resolveSubdomainBases } from "../utils/service-urls.j
 import { discoverResourcesStrict, discoverResourcesWithProblems, discoverStacks, getResourcesForStack, stackExists, warnAboutSkippedFiles, } from "../utils/services.js";
 import { buildSmokePlans, formatSmokeFailure, runSmokePlans, safeSmokeDeps, } from "../utils/smoke.js";
 import { buildStartupReport, formatStartupReport, isStartupStalled, } from "../utils/startup-report.js";
-import { evaluateTdkVersionFloor } from "../utils/tdk-version.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
 import { classifyTiltPorts } from "../utils/tilt-port-owner.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
@@ -87,7 +87,7 @@ export function driftReport(projectRoot, resources) {
             : undefined));
     }
     catch (error) {
-        // A project with no .tdk/project.json has no snapshots to compare. Anything else (a corrupt config) must not skip the gate.
+        // A project with no .flisk/project.json has no snapshots to compare. Anything else (a corrupt config) must not skip the gate.
         if (error instanceof ProjectConfigNotFoundError)
             return null;
         throw error;
@@ -117,16 +117,16 @@ export function enforceDriftGate(projectRoot, options, exit = process.exit) {
     exit(DRIFT_EXIT_CODE);
 }
 /**
- * Runs before anything starts (also under --dry-run, like the drift gate): a project's `minTdkVersion` in
- * .tdk/project.json that this CLI does not meet, or cannot read, exits with 1 and the same text as `flisk doctor`.
- * `ignoreVersion` skips the check and says so. No minTdkVersion means no check.
+ * Runs before anything starts (also under --dry-run, like the drift gate): a project's `minFliskVersion` in
+ * .flisk/project.json that this CLI does not meet, or cannot read, exits with 1 and the same text as `flisk doctor`.
+ * `ignoreVersion` skips the check and says so. No minFliskVersion means no check.
  */
 export function enforceVersionFloor(projectRoot, options, currentVersion = getPackageVersion(), exit = process.exit) {
     if (options.ignoreVersion) {
-        console.warn(chalk.yellow("Warning: --ignore-version set; minTdkVersion was not checked."));
+        console.warn(chalk.yellow("Warning: --ignore-version set; minFliskVersion was not checked."));
         return;
     }
-    const floor = evaluateTdkVersionFloor(projectRoot, currentVersion);
+    const floor = evaluateFliskVersionFloor(projectRoot, currentVersion);
     if (floor.status === "none" || floor.status === "ok")
         return;
     options.onFail?.(`${floor.message}\n${floor.fix}`);
@@ -171,7 +171,7 @@ function waitForTiltUi(port, timeoutMs = 30_000) {
  * file is resolved, read and checked before anything is written or started. Without the option the
  * project `.env` stays the env file of the run, exactly as before.
  *
- * @throws TdkError when the file cannot be used; the run stops before it starts
+ * @throws FliskError when the file cannot be used; the run stops before it starts
  */
 export function selectRunEnvFile(projectRoot, requested) {
     if (requested === undefined)
@@ -187,14 +187,14 @@ export function selectRunEnvFile(projectRoot, requested) {
 }
 /** The machine-readable failure of a refused `--env-file`, and the exit code it stops the run with. */
 function envFileFailure(error) {
-    const suggestions = error instanceof TdkError ? error.suggestions : [];
+    const suggestions = error instanceof FliskError ? error.suggestions : [];
     return {
         failure: {
             code: error instanceof EnvFileError ? error.code : "ENV_FILE_INVALID",
             message: getErrorMessage(error),
             ...(suggestions.length > 0 ? { suggestions } : {}),
         },
-        exitCode: error instanceof TdkError ? error.exitCode : 2,
+        exitCode: error instanceof FliskError ? error.exitCode : 2,
     };
 }
 export const upCommand = new Command("up")
@@ -206,7 +206,7 @@ export const upCommand = new Command("up")
     .option("--dry-run", "Show what would be started without starting", false)
     .option("-f, --force", "Kill existing Tilt process before starting", false)
     .option("--ignore-drift", "Start even if generated files differ from service.json", false)
-    .option("--ignore-version", "Start even if this flisk is older than minTdkVersion in .tdk/project.json", false)
+    .option("--ignore-version", "Start even if this flisk is older than minFliskVersion in .flisk/project.json", false)
     .option("--only <services...>", "Start only these services plus what the Tiltfile enables for them (their dependsOn services and shared infrastructure). With a stack, names must belong to that stack; dependencies may cross stacks")
     .option("--env-file <path>", "Use this project env file for the run instead of .env (for example: --env-file .env.integration)")
     .option("--json", "Print one JSON object on stdout when the stack is ready or the command fails; implies --quiet", false)
@@ -225,7 +225,7 @@ export const upCommand = new Command("up")
     if (versionRoot) {
         enforceVersionFloor(versionRoot, {
             ignoreVersion: options.ignoreVersion,
-            onFail: (message) => emit?.({ ok: false }, [{ code: "TDK_VERSION_TOO_OLD", message }]),
+            onFail: (message) => emit?.({ ok: false }, [{ code: "FLISK_VERSION_TOO_OLD", message }]),
         });
     }
     // The env file of the run. `--env-file` replaces the project .env for this run, so the file is
@@ -234,7 +234,7 @@ export const upCommand = new Command("up")
     let envFileSelection;
     if (options.envFile === undefined) {
         // Without the option the project .env is the env file of the run, whatever the environment
-        // carries: an inherited TDK_ENV_FILE must not change the default.
+        // carries: an inherited FLISK_ENV_FILE must not change the default.
         delete process.env[PROJECT_ENV_FILE_VAR];
     }
     if (options.envFile !== undefined) {
@@ -262,7 +262,7 @@ export const upCommand = new Command("up")
         emit?.({ ok: false }, [{ code: "HOST_UNSUPPORTED", message: hostRefusal }]);
         showErrorAndExit(hostRefusal);
     }
-    const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.TDK_ALLOW_NATIVE_WINDOWS);
+    const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.FLISK_ALLOW_NATIVE_WINDOWS);
     if (platformRefusal)
         showErrorAndExit(platformRefusal);
     // An unknown schemaVersion is refused before the machine check, so --json can name the file even when Bun is missing.
@@ -297,7 +297,7 @@ export const upCommand = new Command("up")
             discoveredStacks = discoverStacks(discoveredResources);
             discoveredStackNames = discoveredStacks.map((stack) => stack.name);
         }
-        // Reject a bad request before anything below can write to the project (.env, runtime assets, .tdk/project.json).
+        // Reject a bad request before anything below can write to the project (.env, runtime assets, .flisk/project.json).
         if (options.only) {
             if (stackName && !stackExists(stackName, discoveredResources)) {
                 const error = errorFactories.stackNotFound(stackName, discoveredStackNames);
@@ -353,11 +353,11 @@ export const upCommand = new Command("up")
                     console.log(chalk.gray(`Added ${addedEnvKeys.join(", ")} to .env (generated; existing values unchanged)`));
                 }
             }
-            // A project made by `flisk import` has .tdk/project.json but no generated files yet. Generate them rather than letting
+            // A project made by `flisk import` has .flisk/project.json but no generated files yet. Generate them rather than letting
             // Tilt fail on a missing Tiltfile.
-            if (foundRoot && !existsSync(join(projectRoot, ".tdk", ".tdk-out", "Tiltfile"))) {
+            if (foundRoot && !existsSync(join(projectRoot, ".flisk", ".flisk-out", "Tiltfile"))) {
                 if (!options.quiet) {
-                    console.log(chalk.gray("No generated Tiltfile yet; generating .tdk/.tdk-out/ ..."));
+                    console.log(chalk.gray("No generated Tiltfile yet; generating .flisk/.flisk-out/ ..."));
                 }
                 await generateMasterConfigs(projectRoot, { quiet: options.quiet });
             }
@@ -367,7 +367,7 @@ export const upCommand = new Command("up")
             }
             const newlyEnabledStacks = enableDiscoveredStacks(projectRoot, discoveredResources);
             if (newlyEnabledStacks.length > 0 && !options.quiet) {
-                console.log(chalk.gray(`Added ${newlyEnabledStacks.join(", ")} to the pre_alpha phase in .tdk/project.json`));
+                console.log(chalk.gray(`Added ${newlyEnabledStacks.join(", ")} to the pre_alpha phase in .flisk/project.json`));
             }
         }
         let servicesToStart;
@@ -441,7 +441,7 @@ export const upCommand = new Command("up")
             console.log(chalk.blue(formatHostPortPlan(hostPortPlan)));
             for (const line of formatPortFallbackNotice(hostPortPlan))
                 console.log(chalk.yellow(line));
-            console.log(chalk.gray("Override with TDK_HTTP_PORT, TDK_HTTPS_PORT, or TDK_POSTGRES_PORT."));
+            console.log(chalk.gray("Override with FLISK_HTTP_PORT, FLISK_HTTPS_PORT, or FLISK_POSTGRES_PORT."));
         }
         if (emit && options.dryRun) {
             emit({
@@ -530,7 +530,7 @@ export const upCommand = new Command("up")
         });
         if (!options.quiet) {
             console.log(chalk.gray("\nRunning tilt up..."));
-            console.log(chalk.gray(`Using Tiltfile: .tdk/.tdk-out/Tiltfile`));
+            console.log(chalk.gray(`Using Tiltfile: .flisk/.flisk-out/Tiltfile`));
         }
         const tiltRun = runTilt("up", tiltArgs, {
             verbose: options.verbose && !options.json,
@@ -626,7 +626,7 @@ export const upCommand = new Command("up")
                 if (ignoreWarning)
                     console.warn(chalk.yellow(ignoreWarning));
                 const results = await runSmokePlans(smokePlans, {
-                    recordDir: join(projectRoot, ".tdk", "smoke"),
+                    recordDir: join(projectRoot, ".flisk", "smoke"),
                     ...safeSmokeDeps(projectRoot, (message) => console.warn(chalk.yellow(message)), {
                         // The selected env file holds secrets as much as the project .env.
                         envFiles: envFileSelection ? [envFileSelection.path] : [],

package/cli/dist/commands/upgrade.js

@@ -19,11 +19,11 @@ import { startSpinner } from "../utils/spinner.js";
 import { extractTarball } from "../utils/tar.js";
 import { findAllOnPath, findOnPath } from "../utils/which.js";
 /** @internal Exported for unit tests only; not part of the package API. */
-export function isStandaloneBinary(tdkPath) {
-    if (isWindows() && tdkPath.toLowerCase().endsWith(".exe"))
+export function isStandaloneBinary(fliskPath) {
+    if (isWindows() && fliskPath.toLowerCase().endsWith(".exe"))
         return true;
     try {
-        const fileInfo = execFileSync("file", ["-b", tdkPath], { encoding: "utf-8" });
+        const fileInfo = execFileSync("file", ["-b", fliskPath], { encoding: "utf-8" });
         return /Mach-O|ELF/.test(fileInfo);
     }
     catch (err) {
@@ -34,7 +34,7 @@ export function isStandaloneBinary(tdkPath) {
 /** @internal Exported for unit tests only; not part of the package API. */
 export function classifyRunningInstall(execPath, scriptPath, platformName = process.platform) {
     const runningName = (platformName === "win32" ? win32.basename(execPath) : basename(execPath)).toLowerCase();
-    if (runningName === "flisk" || runningName === "tdk.exe") {
+    if (runningName === "flisk" || runningName === "flisk.exe") {
         return { method: "binary", path: execPath };
     }
     if (runningName === "node" || runningName === "node.exe") {
@@ -58,24 +58,26 @@ export function detectInstallation() {
     if (runningInstall)
         return runningInstall;
     try {
-        const tdkPath = findOnPath(executableName());
-        if (!tdkPath)
+        const fliskPath = findOnPath(executableName());
+        if (!fliskPath)
             return { method: "unknown" };
         // `readlink -f` is not available on macOS. Use Node's cross-platform
         // realpath implementation so standalone binaries are detected there too.
-        const realPath = realpathSync(tdkPath);
-        // If the real path contains tdk-cli and has .git, it's a linked git install
-        if (realPath.includes("tdk-cli")) {
+        const realPath = realpathSync(fliskPath);
+        // If the real path contains flisk-cli and has .git, it's a linked git install
+        if (realPath.includes("flisk-cli")) {
             const possibleGitRoot = resolve(realPath, "..", "..", "..");
             if (existsSync(join(possibleGitRoot, ".git"))) {
                 return { method: "git", path: possibleGitRoot };
             }
         }
-        if (tdkPath.includes("node_modules") || tdkPath.includes(".npm") || tdkPath.includes(".bun")) {
-            if (tdkPath.includes(".bun")) {
-                return { method: "bun", path: tdkPath };
+        if (fliskPath.includes("node_modules") ||
+            fliskPath.includes(".npm") ||
+            fliskPath.includes(".bun")) {
+            if (fliskPath.includes(".bun")) {
+                return { method: "bun", path: fliskPath };
             }
-            return { method: "npm", path: tdkPath };
+            return { method: "npm", path: fliskPath };
         }
         const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
         if (existsSync(join(cliRoot, ".git"))) {
@@ -86,7 +88,7 @@ export function detectInstallation() {
         if (isStandaloneBinary(realPath)) {
             return { method: "binary", path: realPath };
         }
-        return { method: "unknown", path: tdkPath };
+        return { method: "unknown", path: fliskPath };
     }
     catch (err) {
         console.warn(chalk.yellow("⚠️ Could not detect installation method"));
@@ -95,25 +97,27 @@ export function detectInstallation() {
     }
 }
 /** @internal Exported for unit tests only; not part of the package API. */
-export function detectInstallationForPath(tdkPath) {
+export function detectInstallationForPath(fliskPath) {
     try {
-        const realPath = realpathSync(tdkPath);
-        if (realPath.includes("tdk-cli")) {
+        const realPath = realpathSync(fliskPath);
+        if (realPath.includes("flisk-cli")) {
             const possibleGitRoot = resolve(realPath, "..", "..", "..");
             if (existsSync(join(possibleGitRoot, ".git"))) {
                 return { method: "git", path: possibleGitRoot };
             }
         }
-        if (tdkPath.includes("node_modules") || tdkPath.includes(".npm") || tdkPath.includes(".bun")) {
-            return { method: tdkPath.includes(".bun") ? "bun" : "npm", path: tdkPath };
+        if (fliskPath.includes("node_modules") ||
+            fliskPath.includes(".npm") ||
+            fliskPath.includes(".bun")) {
+            return { method: fliskPath.includes(".bun") ? "bun" : "npm", path: fliskPath };
         }
         if (isStandaloneBinary(realPath))
             return { method: "binary", path: realPath };
     }
     catch (err) {
-        logVerbose(`Installation detection failed for ${tdkPath}`, err);
+        logVerbose(`Installation detection failed for ${fliskPath}`, err);
     }
-    return { method: "unknown", path: tdkPath };
+    return { method: "unknown", path: fliskPath };
 }
 /** @internal Exported for unit tests only; not part of the package API. */
 export function detectAllInstallations() {
@@ -211,11 +215,11 @@ export function isWritable(path) {
     }
 }
 /** @internal Exported for unit tests only; not part of the package API. */
-export async function upgradeViaBinary(tdkPath, release) {
+export async function upgradeViaBinary(fliskPath, release) {
     // Never shells out to sudo - if the install dir isn't user-writable, fail
     // fast with the manual curl command instead of downloading first and
     // elevating automatically. The user runs that curl themselves.
-    const installDir = dirname(tdkPath);
+    const installDir = dirname(fliskPath);
     if (!isWritable(installDir)) {
         console.log(chalk.yellow(`\n🔒 ${installDir} isn't writable by your user.`));
         console.log(chalk.yellow("💡 Upgrade manually instead:"));
@@ -223,19 +227,19 @@ export async function upgradeViaBinary(tdkPath, release) {
             console.log(chalk.cyan("   Install Flisk in a user-writable directory, then retry the upgrade."));
         }
         else {
-            console.log(chalk.cyan(`   curl -fsSL -o ${tdkPath} ${release.downloadUrl}`));
-            console.log(chalk.cyan(`   chmod +x ${tdkPath}`));
+            console.log(chalk.cyan(`   curl -fsSL -o ${fliskPath} ${release.downloadUrl}`));
+            console.log(chalk.cyan(`   chmod +x ${fliskPath}`));
         }
         return false;
     }
     const spinner = startSpinner(`Downloading ${release.assetName} (${release.tag})...`);
-    const tempDir = join(installDir, `.tdk-upgrade-${process.pid}-${Date.now()}`);
+    const tempDir = join(installDir, `.flisk-upgrade-${process.pid}-${Date.now()}`);
     const tmpPath = join(tempDir, release.assetName);
     const engineTmpPath = join(tempDir, "engine.tar.gz");
-    const engineDir = join(installDir, "tdk-cli");
-    const engineStageDir = join(tempDir, "tdk-cli");
-    const binaryBackup = join(tempDir, `${basename(tdkPath)}.previous`);
-    const engineBackup = join(tempDir, "tdk-cli.previous");
+    const engineDir = join(installDir, "flisk-cli");
+    const engineStageDir = join(tempDir, "flisk-cli");
+    const binaryBackup = join(tempDir, `${basename(fliskPath)}.previous`);
+    const engineBackup = join(tempDir, "flisk-cli.previous");
     try {
         mkdirSync(tempDir, { recursive: true });
         const binaryResponse = await fetch(release.downloadUrl, {
@@ -245,8 +249,8 @@ export async function upgradeViaBinary(tdkPath, release) {
             throw new Error(`Download failed (${binaryResponse.status})`);
         writeFileSync(tmpPath, Buffer.from(await binaryResponse.arrayBuffer()));
         // The compiled binary has no source checkout to find engine/ or
-        // cli/templates/ in, so it looks for a tdk-cli/ folder next to itself
-        // (see template-engine.ts loadTemplate() / vendorTdkExtension()).
+        // cli/templates/ in, so it looks for a flisk-cli/ folder next to itself
+        // (see template-engine.ts loadTemplate() / vendorFliskExtension()).
         // `flisk upgrade` only used to swap the binary, leaving that folder
         // stale/missing after an upgrade - refresh it here too, every time,
         // the same way install.sh does on a fresh install.
@@ -275,14 +279,14 @@ export async function upgradeViaBinary(tdkPath, release) {
             chmodSync(tmpPath, 0o755);
         mkdirSync(engineStageDir, { recursive: true });
         extractTarball(engineBuffer, engineStageDir);
-        if (existsSync(tdkPath))
-            renameSync(tdkPath, binaryBackup);
+        if (existsSync(fliskPath))
+            renameSync(fliskPath, binaryBackup);
         try {
-            renameSync(tmpPath, tdkPath);
+            renameSync(tmpPath, fliskPath);
         }
         catch (err) {
             if (existsSync(binaryBackup))
-                renameSync(binaryBackup, tdkPath);
+                renameSync(binaryBackup, fliskPath);
             throw err;
         }
         if (existsSync(engineDir))
@@ -294,8 +298,8 @@ export async function upgradeViaBinary(tdkPath, release) {
             if (existsSync(engineBackup))
                 renameSync(engineBackup, engineDir);
             if (existsSync(binaryBackup)) {
-                rmSync(tdkPath, { force: true });
-                renameSync(binaryBackup, tdkPath);
+                rmSync(fliskPath, { force: true });
+                renameSync(binaryBackup, fliskPath);
             }
             throw err;
         }
@@ -639,7 +643,7 @@ export function createUpgradeCommand() {
             console.log(chalk.yellow("\nManual upgrade using a published package:"));
             console.log(chalk.cyan("   npm install -g @flisk-sh/flisk@latest"));
             console.log(chalk.cyan("   bun install -g @flisk-sh/flisk@latest"));
-            console.log(chalk.cyan("   git:  cd /path/to/tdk-cli && git pull && bun link --force"));
+            console.log(chalk.cyan("   git:  cd /path/to/flisk-cli && git pull && bun link --force"));
             process.exit(1);
         }
         let latestVersion = null;
@@ -782,7 +786,7 @@ export function createUpgradeCommand() {
                 console.log(chalk.cyan("   Commit or stash them, then retry: flisk upgrade"));
             }
             else if (installInfo.method === "binary" && binaryRelease && installInfo.path) {
-                const engineDir = join(dirname(installInfo.path), "tdk-cli");
+                const engineDir = join(dirname(installInfo.path), "flisk-cli");
                 if (isWindows()) {
                     console.log(chalk.cyan("   irm https://flisk.sh/install.ps1 | iex"));
                 }

package/cli/dist/frontend-frameworks/registry.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 Flisk Landscape contributors
 // SPDX-License-Identifier: MIT
-import { TdkError } from "../utils/errors.js";
+import { FliskError } from "../utils/errors.js";
 import { litFrontendProvider } from "./lit.js";
 import { preactFrontendProvider } from "./preact.js";
 import { qwikFrontendProvider } from "./qwik.js";
@@ -61,7 +61,7 @@ export function getFrontendFramework(frameworkId, resourceName) {
         const supportedIds = Object.keys(FRONTEND_FRAMEWORKS).join(", ");
         const isMeta = META_FRAMEWORK_IDS.includes(id);
         const byo = `flisk resource ${resourceName ?? "<name>"} --type bring-your-own`;
-        throw new TdkError(`${isMeta ? `"${frameworkId}" is not a Vite SPA provider` : `Unknown frontend framework "${frameworkId}"`}. Supported frameworks: ${supportedIds}.`, [
+        throw new FliskError(`${isMeta ? `"${frameworkId}" is not a Vite SPA provider` : `Unknown frontend framework "${frameworkId}"`}. Supported frameworks: ${supportedIds}.`, [
             `Use one of: ${supportedIds}`,
             `Omit --framework to use ${DEFAULT_FRONTEND_FRAMEWORK}`,
             ...(isMeta ? [`Create the app with ${id}'s own CLI, then register it: ${byo}`] : []),
@@ -73,7 +73,7 @@ export function resolveFrontendFramework(resourceType, frameworkId, resourceName
     if (resourceType !== "frontend") {
         // Backends take their own framework ids (see backend-frameworks/registry.ts).
         if (frameworkId !== undefined && resourceType !== "backend") {
-            throw new TdkError("--framework can only be used with --type frontend or --type backend.", [
+            throw new FliskError("--framework can only be used with --type frontend or --type backend.", [
                 "Add --type frontend or --type backend, or drop --framework for this resource type",
             ]);
         }

package/cli/dist/generator/extension-fetch.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Fetches the paid-tier "premium" resource bundle (playwright, c4-diagram,
 // logging, agents-md, sablier, verdaccio, and a few other extras - see
-// tdk-cli-extensions/premium/) from the gated distribution worker, when a
+// flisk-cli-extensions/premium/) from the gated distribution worker, when a
 // license key is configured. The free engine never needs this for its own
 // resources - docker-compose, npm, bun, etc. are already public in this
 // repo, no key required.
@@ -30,6 +30,9 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "no
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { extractTarball } from "../utils/tar.js";
+// The worker keeps its pre-rename name (tdk-extension-dist, see wrangler.toml
+// in flisk-extension-dist); the worker name sets the hostname, so the live
+// host is still tdk-*. Switch back once the worker itself is renamed.
 const DEFAULT_ENDPOINT = "https://tdk-extension-dist.oranguman.workers.dev/v1/premium/bundle.tar.gz";
 // Tried in order until one is granted - the worker unlocks the whole
 // bundle on the first resource name a key is found to grant, since
@@ -66,21 +69,21 @@ const PREMIUM_PATH_MAP = {
     "registries/verdaccio_loader.star": "engine/topologies/platform/registries/verdaccio_loader.star",
 };
 function getLicenseKey() {
-    return process.env.TDK_LICENSE_KEY?.trim() || null;
+    return process.env.FLISK_LICENSE_KEY?.trim() || null;
 }
 function getEndpoint() {
-    return process.env.TDK_PREMIUM_ENDPOINT?.trim() || DEFAULT_ENDPOINT;
+    return process.env.FLISK_PREMIUM_ENDPOINT?.trim() || DEFAULT_ENDPOINT;
 }
 // A stable per-project id for the worker's project-limit tracking - not a
 // device or user id. Generated once and persisted alongside the rest of
-// the project's .tdk/ state.
+// the project's .flisk/ state.
 function getOrCreateProjectId(projectRoot) {
-    const idPath = join(projectRoot, ".tdk", ".project-id");
+    const idPath = join(projectRoot, ".flisk", ".project-id");
     if (existsSync(idPath)) {
         return readFileSync(idPath, "utf-8").trim();
     }
     const id = randomUUID();
-    mkdirSync(join(projectRoot, ".tdk"), { recursive: true });
+    mkdirSync(join(projectRoot, ".flisk"), { recursive: true });
     writeFileSync(idPath, `${id}\n`);
     return id;
 }
@@ -89,7 +92,7 @@ function cacheTarballPath(key) {
     // machine) so switching license keys doesn't serve a stale bundle
     // fetched under a different plan.
     const safeName = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join(homedir(), ".tdk", "cache", `premium-${safeName}`, "premium.tar.gz");
+    return join(homedir(), ".flisk", "cache", `premium-${safeName}`, "premium.tar.gz");
 }
 function isCacheFresh(path) {
     if (!existsSync(path))
@@ -189,7 +192,7 @@ export async function applyPremiumOverlay(projectRoot, destDir) {
         if (missing.length > 0) {
             console.info(`🔎 Premium bundle missing mapped files: ${missing.join(", ")}`);
         }
-        if (!existsSync(sablierPath) && process.env.TDK_PREMIUM_DIAGNOSTICS === "1") {
+        if (!existsSync(sablierPath) && process.env.FLISK_PREMIUM_DIAGNOSTICS === "1") {
             const sablierGranted = await hasSablierLicense(projectRoot);
             console.info(`🔎 Sablier entitlement check: ${sablierGranted ? "granted" : "not confirmed"}; compare with sablier_overlay above to distinguish license access from bundle contents`);
         }
@@ -206,7 +209,7 @@ export async function applyPremiumOverlay(projectRoot, destDir) {
 }
 function liveResourceAccessCachePath(key, resource) {
     const safeName = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join(homedir(), ".tdk", "cache", `premium-${safeName}`, `${resource}-access.json`);
+    return join(homedir(), ".flisk", "cache", `premium-${safeName}`, `${resource}-access.json`);
 }
 /**
  * Checks whether the configured license key grants a given "live" premium