@fjall/util 0.96.0 → 0.99.3

package/dist/docker/projectBuildxResult.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure projection: `BuildxBuildResult` → consumer-facing
+ * `DockerBuildResultLike`. PR 1 (CLI adapter) and PR 2 (worker adapter)
+ * both call this single function so the deploy-core `DockerBuildResult`
+ * shape is produced symmetrically from either side; parity tests assert
+ * byte-identical output for matching inputs.
+ *
+ * `DockerBuildResultLike` is a structural mirror of deploy-core's
+ * `DockerBuildResult` (orchestration/dockerInterface.ts). Defined locally
+ * to keep `@fjall/util` at the root of the workspace dep graph — adapters
+ * upcast structurally at their boundary.
+ *
+ * Required digest source: `BuildxBuildResult.imageDigests` (one entry per
+ * pushed/loaded tag). When the primary tag has no digest in the map we
+ * fail with `metadata_missing_digest` per design § 3.1.1.
+ */
+import type { BuildxBuildResult, DockerCliError } from "./dockerCliSchemas.js";
+import { type Result } from "./result.js";
+export interface DockerBuildResultLike {
+    readonly imageUri: string;
+    readonly imageTag: string;
+    readonly services?: ReadonlyArray<{
+        name: string;
+        imageUri: string;
+    }>;
+}
+export interface ProjectBuildxResultArgs {
+    readonly result: BuildxBuildResult;
+    readonly primaryTag: string;
+    readonly services?: ReadonlyArray<{
+        name: string;
+        tag: string;
+    }>;
+}
+export declare function projectBuildxResult(args: ProjectBuildxResultArgs): Result<DockerBuildResultLike, DockerCliError>;

package/dist/docker/projectBuildxResult.js

@@ -0,0 +1 @@
+import{makeError as n}from"./DockerCli.js";import{failure as g,success as o}from"./result.js";function c(s){const e=s.lastIndexOf(":");return e===-1||s.lastIndexOf("/")>e?s:s.slice(e+1)}function l(s){const{result:e,primaryTag:t,services:a}=s;if(e.imageDigests[t]===void 0)return g(n("metadata_missing_digest",`Buildx result has no digest for primary tag ${t}`,{primaryTag:t,availableTags:Object.keys(e.imageDigests)}));const r=[];if(a!==void 0)for(const i of a){if(e.imageDigests[i.tag]===void 0)return g(n("metadata_missing_digest",`Buildx result has no digest for service ${i.name} tag ${i.tag}`,{service:i.name,tag:i.tag,availableTags:Object.keys(e.imageDigests)}));r.push({name:i.name,imageUri:i.tag})}return o({imageUri:t,imageTag:c(t),...r.length>0&&{services:r}})}export{l as projectBuildxResult};

package/dist/docker/rawjsonParser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Defensive line-by-line parser for `docker buildx build --progress=rawjson` stdout.
+ *
+ * Line contract: the caller is responsible for buffering subprocess stdout
+ * chunks into newline-delimited lines. This function consumes exactly one
+ * complete line per call and never returns partial parses.
+ *
+ * `RawjsonEnvelope` is a TS-typed structural shape, NOT a Zod schema.
+ * Buildx is the upstream producer and ships new fields between minor
+ * versions; a `.strict()` schema would reject valid output the moment
+ * a buildx upgrade lands. The external-API exemption from typescript-
+ * standards Pitfall 3 applies. Unknown keys are preserved on the
+ * `extra` record so downstream consumers and diagnostics can still see
+ * what was sent.
+ *
+ * Returns `null` only when the line is not parseable as JSON, or is a
+ * JSON value other than a non-array object (e.g. a top-level string,
+ * number, or array — none of which are valid rawjson envelopes).
+ */
+export interface RawjsonVertex {
+    readonly digest?: string;
+    readonly name?: string;
+    readonly started?: string;
+    readonly completed?: string;
+    readonly cached?: boolean;
+    readonly error?: string;
+    readonly inputs?: readonly string[];
+}
+export interface RawjsonStatus {
+    readonly id?: string;
+    readonly vertex?: string;
+    readonly name?: string;
+    readonly current?: number;
+    readonly total?: number;
+    readonly started?: string;
+    readonly completed?: string;
+}
+export interface RawjsonLog {
+    readonly vertex?: string;
+    readonly stream?: number;
+    readonly data?: string;
+    readonly timestamp?: string;
+}
+export interface RawjsonWarning {
+    readonly vertex?: string;
+    readonly level?: string;
+    readonly short?: string;
+}
+export interface RawjsonEnvelope {
+    readonly vertexes?: readonly RawjsonVertex[];
+    readonly statuses?: readonly RawjsonStatus[];
+    readonly logs?: readonly RawjsonLog[];
+    readonly warnings?: readonly RawjsonWarning[];
+    readonly extra: Readonly<Record<string, unknown>>;
+}
+export declare function parseRawjsonLine(line: string): RawjsonEnvelope | null;

package/dist/docker/rawjsonParser.js

@@ -0,0 +1 @@
+const o=new Set(["vertexes","statuses","logs","warnings"]);function l(a){const e=a.trim();if(e==="")return null;let s;try{s=JSON.parse(e)}catch{return null}if(s===null||typeof s!="object"||Array.isArray(s))return null;const r=s,t={};for(const[n,i]of Object.entries(r))o.has(n)||(t[n]=i);return{...Array.isArray(r.vertexes)&&{vertexes:r.vertexes},...Array.isArray(r.statuses)&&{statuses:r.statuses},...Array.isArray(r.logs)&&{logs:r.logs},...Array.isArray(r.warnings)&&{warnings:r.warnings},extra:t}}export{l as parseRawjsonLine};

package/dist/docker/rawjsonToVertexEvent.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Self-contained adapter: `RawjsonEnvelope` → `RawjsonVertexEvent`.
+ *
+ * The output shape is OWNED by `@fjall/util/docker`. It does NOT import
+ * from `@fjall/cli` or any cli-side BuildKit decoder module — that bridge
+ * is a PR 2 concern. The shape below is structurally compatible with the
+ * cli-side `BuildKitStateManager` input (`BuildKitStatusResponse`); the
+ * PR 2 bridge maps these fields directly.
+ *
+ * Field mapping the PR 2 bridge will use:
+ *   vertex.digest     → BuildKitVertex.digest
+ *   vertex.name       → BuildKitVertex.name
+ *   vertex.started    → BuildKitVertex.started (timestamp)
+ *   vertex.completed  → BuildKitVertex.completed (timestamp)
+ *   vertex.error      → BuildKitVertex.error
+ *   log.data          → BuildKitVertexLog.data (base64-encoded; consumer decodes)
+ *   log.stream        → BuildKitVertexLog.stream (1=stdout, 2=stderr)
+ *   status.id         → BuildKitVertexStatus.id
+ *   status.name       → BuildKitVertexStatus.name
+ *
+ * Same external-API exemption as `rawjsonParser.ts`: this shape is
+ * structural-typed, not Zod-validated. Buildx ships new fields without
+ * notice; a `.strict()` schema would reject valid output.
+ *
+ * Returns `null` if the envelope has no extractable vertex/status/log/warning
+ * arrays (e.g. when `extra` contains buildx-private metadata only).
+ */
+import type { RawjsonEnvelope } from "./rawjsonParser.js";
+export interface NormalisedVertex {
+    readonly digest: string;
+    readonly name: string;
+    readonly started?: string;
+    readonly completed?: string;
+    readonly cached?: boolean;
+    readonly error?: string;
+    readonly inputs?: readonly string[];
+}
+export interface NormalisedStatus {
+    readonly id: string;
+    readonly vertex: string;
+    readonly name: string;
+    readonly current: number;
+    readonly total?: number;
+    readonly started?: string;
+    readonly completed?: string;
+}
+export interface NormalisedLog {
+    readonly vertex: string;
+    readonly stream: "stdout" | "stderr";
+    readonly data: string;
+    readonly timestamp?: string;
+}
+export interface NormalisedWarning {
+    readonly vertex: string;
+    readonly level: string;
+    readonly short: string;
+}
+export interface RawjsonVertexEvent {
+    readonly vertexes: readonly NormalisedVertex[];
+    readonly statuses: readonly NormalisedStatus[];
+    readonly logs: readonly NormalisedLog[];
+    readonly warnings: readonly NormalisedWarning[];
+}
+export declare function rawjsonToVertexEvent(envelope: RawjsonEnvelope): RawjsonVertexEvent | null;

package/dist/docker/rawjsonToVertexEvent.js

@@ -0,0 +1 @@
+function u(t){return typeof t.digest!="string"||t.digest===""||typeof t.name!="string"||t.name===""?null:{digest:t.digest,name:t.name,...typeof t.started=="string"&&{started:t.started},...typeof t.completed=="string"&&{completed:t.completed},...typeof t.cached=="boolean"&&{cached:t.cached},...typeof t.error=="string"&&{error:t.error},...Array.isArray(t.inputs)&&{inputs:t.inputs}}}function f(t){return typeof t.id!="string"||t.id===""||typeof t.vertex!="string"||t.vertex===""||typeof t.name!="string"||typeof t.current!="number"?null:{id:t.id,vertex:t.vertex,name:t.name,current:t.current,...typeof t.total=="number"&&{total:t.total},...typeof t.started=="string"&&{started:t.started},...typeof t.completed=="string"&&{completed:t.completed}}}function l(t){if(typeof t.vertex!="string"||t.vertex===""||typeof t.data!="string")return null;const n=t.stream===2?"stderr":"stdout";return{vertex:t.vertex,stream:n,data:t.data,...typeof t.timestamp=="string"&&{timestamp:t.timestamp}}}function a(t){return typeof t.vertex!="string"||t.vertex===""||typeof t.short!="string"?null:{vertex:t.vertex,level:typeof t.level=="string"?t.level:"warning",short:t.short}}function c(t){const n=[];for(const r of t.vertexes??[]){const e=u(r);e!==null&&n.push(e)}const o=[];for(const r of t.statuses??[]){const e=f(r);e!==null&&o.push(e)}const s=[];for(const r of t.logs??[]){const e=l(r);e!==null&&s.push(e)}const i=[];for(const r of t.warnings??[]){const e=a(r);e!==null&&i.push(e)}return n.length===0&&o.length===0&&s.length===0&&i.length===0?null:{vertexes:n,statuses:o,logs:s,warnings:i}}export{c as rawjsonToVertexEvent};

package/dist/docker/result.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Local `Result<T, E>` for `@fjall/util/docker`.
+ *
+ * The canonical Result type lives in `@fjall/generator/src/types/Result.ts`
+ * and is re-exported through `@fjall/deploy-core`. We do NOT import either
+ * here: `@fjall/util` has no `@fjall/*` dependencies (it is the root of the
+ * workspace dep graph) and adding one would create a circular workspace
+ * dependency (generator already depends on util).
+ *
+ * The shape below is structurally identical to the canonical Result, so
+ * adapters in `@fjall/cli` (PR 2) and `webapp` (PR 1) consume values
+ * produced here and pass them through to deploy-core consumers without
+ * conversion. If the canonical Result shape ever changes, the bridge will
+ * fail to typecheck — that is the drift signal.
+ *
+ * Reference: `fjall/generator/src/types/Result.ts`.
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+export declare function isSuccess<T, E>(result: Result<T, E>): result is {
+    success: true;
+    data: T;
+};
+export declare function isFailure<T, E>(result: Result<T, E>): result is {
+    success: false;
+    error: E;
+};
+export declare function success<T>(data: T): Result<T, never>;
+export declare function failure<E>(error: E): Result<never, E>;

package/dist/docker/result.js

@@ -0,0 +1 @@
+function e(s){return s.success===!0}function u(s){return s.success===!1}function c(s){return{success:!0,data:s}}function r(s){return{success:!1,error:s}}export{r as failure,u as isFailure,e as isSuccess,c as success};

package/dist/errorUtils.d.ts

@@ -1,9 +1,17 @@
 /**
- * Normalise an unknown thrown value into an Error instance
+ * Error extractor helpers consumed by the
+ * `fjall/mask-error-message-at-boundary` ESLint rule by name. Renaming any
+ * of `getErrorMessage`, `getErrorStack`, or `formatErrorString` requires a
+ * matching update in `cli/eslint-rules/mask-error-message-at-boundary.js`
+ * (`ERROR_EXTRACTOR_CALLEES`).
+ *
+ * Normalise an unknown thrown value into an Error instance.
  */
 export declare function normaliseError(error: unknown): Error;
 /**
- * Safely extract error message from any error type
+ * Safely extract error message from any error type. Extractor helper —
+ * see file-header note. Result MUST be wrapped in `maskSensitiveOutput()`
+ * before reaching any logger / state setter / persistence / callback sink.
  */
 export declare function getErrorMessage(error: unknown): string;
 /**
@@ -15,10 +23,12 @@ export declare function hasErrorCode(error: unknown, code: string): boolean;
  */
 export declare function getErrorCode(error: unknown): string | undefined;
 /**
- * Safely extract the stack trace from an unknown thrown value
+ * Safely extract the stack trace from an unknown thrown value. Extractor
+ * helper — must be `maskSensitiveOutput()`-wrapped at every sink.
  */
 export declare function getErrorStack(error: unknown): string | undefined;
 /**
- * Create a formatted error string with optional code prefix
+ * Create a formatted error string with optional code prefix. Extractor
+ * helper — must be `maskSensitiveOutput()`-wrapped at every sink.
  */
 export declare function formatErrorString(error: unknown): string;

package/dist/findInfrastructurePaths.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared marker-path resolver for cross-system scan parity.
+ *
+ * Both the CLI's `scanLocalRepository` (filesystem walker) and the webapp's
+ * `scanInfrastructureFiles` (GitHub tree API) need the same answer to:
+ *
+ *   "Given a path, is it an `infrastructure.ts` inside a `fjall/` boundary,
+ *    and if so, what is its `configPath` + `boundaryPath`?"
+ *
+ * This module is the single source of truth for that resolution. Each
+ * scanner is responsible for its own I/O (walk filesystem / list GitHub
+ * tree); both hand the resulting iterable of `{ path }` entries to
+ * `findInfrastructurePaths`, optionally pre-filtered via the options below.
+ *
+ * No I/O. Pure path classification. The structural contract is the function
+ * signature; review-time agreement is not load-bearing.
+ *
+ * See `aiDocs/patterns/fjall-marker-convention-pattern.md` for the convention
+ * and `aiDocs/decisions/2026-05-11-scan-parity-contract-vs-structural.md`
+ * for the rationale behind extracting this module.
+ */
+import type { ScanPath } from "./scanTypes.js";
+export declare const MARKER_DIRECTORY = "fjall";
+export interface MarkerEntry {
+    /** POSIX-style path relative to the repo root. */
+    path: string;
+}
+export interface FindInfrastructurePathsOptions {
+    /**
+     * Reject entries whose path starts with any of these prefixes. Use for
+     * exclusion sets that span subtrees (e.g. `"node_modules/"`,
+     * `".fjall/history/"`). Each prefix MUST end with `/` to keep the match
+     * directory-aware.
+     */
+    excludedPathPrefixes?: readonly string[];
+    /**
+     * Reject entries that include any of these path segments anywhere in their
+     * path (excluding the filename segment). Use for build-output directories
+     * the consumer's I/O layer cannot prune at walk time (e.g. `"dist"`,
+     * `".turbo"`). Match is segment-exact.
+     */
+    excludedPathSegments?: ReadonlySet<string>;
+}
+/**
+ * Resolve an iterable of repo-relative paths to the subset that are
+ * `infrastructure.ts` files inside a `fjall/` boundary. Returns one
+ * `{ configPath, boundaryPath }` per match.
+ *
+ * Boundary rule: the **leftmost** path segment named exactly `fjall` wins.
+ * Nested `fjall/` folders inside the boundary do not redefine it.
+ *
+ * The caller is responsible for any cap or ranking; this function applies
+ * neither. Exclusion via `options` is OPTIONAL — consumers that pre-filter
+ * at their I/O layer may omit it.
+ */
+export declare function findInfrastructurePaths(entries: Iterable<MarkerEntry>, options?: FindInfrastructurePathsOptions): ScanPath[];
+export declare function isInfrastructureFile(path: string): boolean;
+/**
+ * Return the path to the leftmost `fjall/` ancestor, or `null` if the path
+ * does not cross a `fjall/` boundary. The result excludes the file segment.
+ */
+export declare function findBoundaryPath(path: string): string | null;

package/dist/findInfrastructurePaths.js

@@ -0,0 +1 @@
+const i="infrastructure.ts",f="fjall";function x(t,e){const n=e?.excludedPathPrefixes,r=e?.excludedPathSegments,s=[];for(const u of t){if(!c(u.path)||n&&h(u.path,n)||r&&d(u.path,r))continue;const o=a(u.path);o!==null&&s.push({configPath:l(u.path),boundaryPath:o})}return s}function c(t){return t===i||t.endsWith(`/${i}`)}function a(t){const e=t.split("/");for(let n=0;n<e.length-1;n++)if(e[n]===f)return e.slice(0,n+1).join("/");return null}function l(t){return t.slice(0,-`/${i}`.length)}function h(t,e){for(const n of e)if(t.startsWith(n))return!0;return!1}function d(t,e){const n=t.split("/");for(let r=0;r<n.length-1;r++)if(e.has(n[r]))return!0;return!1}export{f as MARKER_DIRECTORY,a as findBoundaryPath,x as findInfrastructurePaths,c as isInfrastructureFile};

package/dist/findRepoRoot.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Walk parents from `cwd` looking for the nearest enclosing repository
+ * root, identified by either a `.git/` directory or a `fjall-config.json`
+ * file. Returns the absolute path of the first directory matching either
+ * marker, or falls back to `cwd` when no ancestor matches.
+ *
+ * Used by the CLI scaffold pre-flight so `scanLocalRepository` always
+ * walks from the repo root: a `fjall create app` run from
+ * `services/api/` still discovers existing markers under
+ * `services/worker/fjall/`, not only the descendants of `cwd`.
+ */
+export declare function findRepoRoot(cwd: string): Promise<string>;

package/dist/findRepoRoot.js

@@ -0,0 +1 @@
+import{stat as a}from"fs/promises";import{dirname as f,join as c,parse as m,resolve as o}from"path";const u=[".git","fjall-config.json"];async function h(r){let t=o(r);const{root:n}=m(t);for(;;){for(const s of u){const i=c(t,s);if(await a(i).then(()=>!0,()=>!1))return t}if(t===n)return o(r);const e=f(t);if(e===t)return o(r);t=e}}export{h as findRepoRoot};

package/dist/fsHelpers.d.ts

@@ -2,3 +2,18 @@
  * Async check for file existence. Replaces blocking existsSync().
  */
 export declare function fileExists(filePath: string): Promise<boolean>;
+export interface AtomicWriteOptions {
+    /** File mode for the destination file. Default 0o644. */
+    mode?: number;
+    /**
+     * Called when tmp-file cleanup fails after a write/rename error.
+     * Receives the cleanup error so the caller can log it. Default: ignore.
+     */
+    onCleanupError?: (err: unknown) => void;
+}
+/**
+ * Atomically write a file via mkdtemp-style tmp + rename. Crash-safe:
+ * the destination either contains the previous bytes or the new bytes,
+ * never a partial write.
+ */
+export declare function atomicWrite(filePath: string, contents: string | Uint8Array, options?: AtomicWriteOptions): void;

package/dist/fsHelpers.js

@@ -1 +1 @@
-import{access as e,constants as c}from"fs/promises";async function o(t){try{return await e(t,c.F_OK),!0}catch(r){if(r instanceof Error&&"code"in r&&r.code==="ENOENT")return!1;throw r}}export{o as fileExists};
+import{access as i,constants as m}from"fs/promises";import{renameSync as s,unlinkSync as f,writeFileSync as p}from"node:fs";import{randomBytes as u}from"node:crypto";async function d(t){try{return await i(t,m.F_OK),!0}catch(r){if(r instanceof Error&&"code"in r&&r.code==="ENOENT")return!1;throw r}}function l(t,r,n={}){const o=`${t}.${u(6).toString("hex")}.tmp`,e=n.mode??420;try{p(o,r,{mode:e}),s(o,t)}catch(c){try{f(o)}catch(a){n.onCleanupError?.(a)}throw c}}export{l as atomicWrite,d as fileExists};

package/dist/fsScan.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Filesystem-bound `@fjall/util` subpath barrel.
+ *
+ * The helpers here depend on `fs/promises`, which MUST NOT reach webapp
+ * client bundles. The subpath split (vs the top-level `@fjall/util`
+ * barrel) enforces that boundary: the top-level barrel stays pure and
+ * tree-shakable into the browser; anything node-only ships here.
+ *
+ * Consumers:
+ *   - CLI (`createAppHandler`) → both `scanLocalRepository` + `findRepoRoot`
+ *   - Webapp server-side code may import here too; webapp client code MUST NOT.
+ */
+export { scanLocalRepository, type ScanLocalRepositoryResult } from "./scanLocalRepository.js";
+export { findRepoRoot } from "./findRepoRoot.js";
+export { type ScanPath } from "./scanTypes.js";

package/dist/fsScan.js

@@ -0,0 +1 @@
+import{scanLocalRepository as e}from"./scanLocalRepository.js";import{findRepoRoot as t}from"./findRepoRoot.js";export{t as findRepoRoot,e as scanLocalRepository};

package/dist/index.d.ts

@@ -8,4 +8,12 @@ export { STANDARD_ENVIRONMENTS, STRUCTURAL_ENVIRONMENTS, type StandardEnvironmen
 export { RESOURCE_CATEGORIES, type ResourceCategory, categoriseResource, getExpectedDuration, getFriendlyResourceType } from "./resourceCategorisation.js";
 export { parseGitRemoteUrl, type GitProvider, type ParsedGitRemote } from "./gitRemoteParser.js";
 export { abbreviateRegion } from "./regions.js";
+export { SCOPE_VALUES, type TokenScope } from "./tokenScopes.js";
 export { deriveRegionsFromOrgConfig, deriveTargets, deriveAllTargets, findTarget, generateTargetName, type OrgConfigRegions, type TargetAccount, type DerivedTarget } from "./targets.js";
+export { buildAppConfigPath } from "./appPath.js";
+export { type ScanPath } from "./scanTypes.js";
+export { findInfrastructurePaths, findBoundaryPath, isInfrastructureFile, type MarkerEntry, type FindInfrastructurePathsOptions } from "./findInfrastructurePaths.js";
+export { inferContainerFromCandidates } from "./inferContainerFromCandidates.js";
+export { RESERVED_APP_NAMES, type ReservedAppName, isReservedAppName } from "./reservedAppNames.js";
+export { deriveContentHashTag } from "./deriveContentHashTag.js";
+export { MIGRATION_SNAPSHOT_NAME_PREFIX, EXPECTED_SCHEMA_VERSION_ENV, EXPECTED_SCHEMA_VERSION_TOOL_ENV, PRISMA_MIGRATION_DIR_RE } from "./migration/constants.js";

package/dist/index.js

@@ -1 +1 @@
-import{DNS_APEX as o,getDomainExportNames as t}from"./domainExports.js";import{toPascalCase as i,toKebab as s,toValidDatabaseName as E,toScreamingSnake as g,capitalise as m,getSafeZoneName as n}from"./caseConversion.js";import{normaliseError as N,getErrorMessage as S,hasErrorCode as f,getErrorCode as R,getErrorStack as l,formatErrorString as x}from"./errorUtils.js";import{singleton as d}from"./singleton.js";import{DANGEROUS_ENV_VARS as c,filterDangerousEnvVars as v,maskSensitiveOutput as D,parseShellArgs as O}from"./securityHelpers.js";import{sleep as C}from"./sleep.js";import{STANDARD_ENVIRONMENTS as b,STRUCTURAL_ENVIRONMENTS as u,isValidEnvironment as U,ENVIRONMENT_LABELS as I,getEnvironmentLabel as L}from"./environments.js";import{RESOURCE_CATEGORIES as k,categoriseResource as G,getExpectedDuration as h,getFriendlyResourceType as y}from"./resourceCategorisation.js";import{parseGitRemoteUrl as P}from"./gitRemoteParser.js";import{abbreviateRegion as K}from"./regions.js";import{deriveRegionsFromOrgConfig as Z,deriveTargets as j,deriveAllTargets as q,findTarget as w,generateTargetName as z}from"./targets.js";export{c as DANGEROUS_ENV_VARS,o as DNS_APEX,I as ENVIRONMENT_LABELS,k as RESOURCE_CATEGORIES,b as STANDARD_ENVIRONMENTS,u as STRUCTURAL_ENVIRONMENTS,K as abbreviateRegion,m as capitalise,G as categoriseResource,q as deriveAllTargets,Z as deriveRegionsFromOrgConfig,j as deriveTargets,v as filterDangerousEnvVars,w as findTarget,x as formatErrorString,z as generateTargetName,t as getDomainExportNames,L as getEnvironmentLabel,R as getErrorCode,S as getErrorMessage,l as getErrorStack,h as getExpectedDuration,y as getFriendlyResourceType,n as getSafeZoneName,f as hasErrorCode,U as isValidEnvironment,D as maskSensitiveOutput,N as normaliseError,P as parseGitRemoteUrl,O as parseShellArgs,d as singleton,C as sleep,s as toKebab,i as toPascalCase,g as toScreamingSnake,E as toValidDatabaseName};
+import{DNS_APEX as o,getDomainExportNames as t}from"./domainExports.js";import{toPascalCase as E,toKebab as i,toValidDatabaseName as n,toScreamingSnake as m,capitalise as s,getSafeZoneName as p}from"./caseConversion.js";import{normaliseError as S,getErrorMessage as N,hasErrorCode as R,getErrorCode as g,getErrorStack as _,formatErrorString as A}from"./errorUtils.js";import{singleton as T}from"./singleton.js";import{DANGEROUS_ENV_VARS as l,filterDangerousEnvVars as C,maskSensitiveOutput as O,parseShellArgs as I}from"./securityHelpers.js";import{sleep as P}from"./sleep.js";import{STANDARD_ENVIRONMENTS as D,STRUCTURAL_ENVIRONMENTS as M,isValidEnvironment as c,ENVIRONMENT_LABELS as v,getEnvironmentLabel as b}from"./environments.js";import{RESOURCE_CATEGORIES as L,categoriseResource as U,getExpectedDuration as F,getFriendlyResourceType as G}from"./resourceCategorisation.js";import{parseGitRemoteUrl as X}from"./gitRemoteParser.js";import{abbreviateRegion as y}from"./regions.js";import{SCOPE_VALUES as K}from"./tokenScopes.js";import{deriveRegionsFromOrgConfig as j,deriveTargets as q,deriveAllTargets as w,findTarget as z,generateTargetName as J}from"./targets.js";import{buildAppConfigPath as W}from"./appPath.js";import{findInfrastructurePaths as $,findBoundaryPath as ee,isInfrastructureFile as re}from"./findInfrastructurePaths.js";import{inferContainerFromCandidates as te}from"./inferContainerFromCandidates.js";import{RESERVED_APP_NAMES as Ee,isReservedAppName as ie}from"./reservedAppNames.js";import{deriveContentHashTag as me}from"./deriveContentHashTag.js";import{MIGRATION_SNAPSHOT_NAME_PREFIX as pe,EXPECTED_SCHEMA_VERSION_ENV as fe,EXPECTED_SCHEMA_VERSION_TOOL_ENV as Se,PRISMA_MIGRATION_DIR_RE as Ne}from"./migration/constants.js";export{l as DANGEROUS_ENV_VARS,o as DNS_APEX,v as ENVIRONMENT_LABELS,fe as EXPECTED_SCHEMA_VERSION_ENV,Se as EXPECTED_SCHEMA_VERSION_TOOL_ENV,pe as MIGRATION_SNAPSHOT_NAME_PREFIX,Ne as PRISMA_MIGRATION_DIR_RE,Ee as RESERVED_APP_NAMES,L as RESOURCE_CATEGORIES,K as SCOPE_VALUES,D as STANDARD_ENVIRONMENTS,M as STRUCTURAL_ENVIRONMENTS,y as abbreviateRegion,W as buildAppConfigPath,s as capitalise,U as categoriseResource,w as deriveAllTargets,me as deriveContentHashTag,j as deriveRegionsFromOrgConfig,q as deriveTargets,C as filterDangerousEnvVars,ee as findBoundaryPath,$ as findInfrastructurePaths,z as findTarget,A as formatErrorString,J as generateTargetName,t as getDomainExportNames,b as getEnvironmentLabel,g as getErrorCode,N as getErrorMessage,_ as getErrorStack,F as getExpectedDuration,G as getFriendlyResourceType,p as getSafeZoneName,R as hasErrorCode,te as inferContainerFromCandidates,re as isInfrastructureFile,ie as isReservedAppName,c as isValidEnvironment,O as maskSensitiveOutput,S as normaliseError,X as parseGitRemoteUrl,I as parseShellArgs,T as singleton,P as sleep,i as toKebab,E as toPascalCase,m as toScreamingSnake,n as toValidDatabaseName};

package/dist/inferContainerFromCandidates.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure inference of the monorepo container directory from a list of
+ * scan paths.
+ *
+ * Each `ScanPath` carries a `boundaryPath` ending in the `fjall` marker
+ * segment. Stripping that segment yields the container — the directory
+ * between repo root and the `fjall/` boundary. For multiple paths, returns
+ * the longest common ancestor.
+ *
+ * Edge cases:
+ *   - empty array                       → `null`
+ *   - boundary at repo root (`fjall`)   → `null`
+ *   - single nested boundary            → its parent directory
+ *   - two with a common ancestor        → the ancestor
+ *   - two with no common ancestor       → `null`
+ *
+ * Pure function — no I/O. Used by both the CLI scaffold pre-flight
+ * (`scanLocalRepository`) and the webapp scan endpoint
+ * (`scanInfrastructureFiles`) to suggest a default `--container` for new
+ * apps.
+ */
+import type { ScanPath } from "./scanTypes.js";
+export declare function inferContainerFromCandidates(paths: readonly ScanPath[]): string | null;

package/dist/inferContainerFromCandidates.js

@@ -0,0 +1 @@
+import{MARKER_DIRECTORY as u}from"./findInfrastructurePaths.js";function h(t){if(t.length===0)return null;const n=[];for(const e of t){const o=f(e.boundaryPath);if(o===null)return null;n.push(o)}const r=c(n);return r.length===0?null:r.join("/")}function f(t){const n=t.split("/").filter(e=>e.length>0);if(n.length===0||n[n.length-1]!==u)return null;const r=n.slice(0,n.length-1);return r.length===0?null:r}function c(t){if(t.length===0)return[];const[n,...r]=t,e=[];for(let o=0;o<n.length;o+=1){const l=n[o];for(const i of r)if(i[o]!==l)return e;e.push(l)}return e}export{h as inferContainerFromCandidates};

package/dist/manifest/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Barrel re-export for `@fjall/util/manifest`.
+ *
+ * NOTE on purity: this barrel imports the I/O module, which depends on
+ * `fs/promises`. Consumers that must remain Node-free (the generator's
+ * pure CDK synth path) MUST import directly from `./schemas` instead of
+ * the barrel — the package.json `exports` map exposes both subpaths.
+ */
+export { DockerBuildSchema, DockerBuildPartialSchema, mergeDockerBuild, ManifestServiceSchema, ManifestPatternSchema, ManifestEcrSchema, ManifestLambdaSchema, ManifestStackHashSchema, ResourceMapEntrySchema, FjallManifestSchema, FJALL_MANIFEST_FILENAME, MANIFEST_SCHEMA_VERSION, type DockerBuild, type DockerBuildPartial, type ManifestService, type ManifestPattern, type ManifestEcr, type ManifestLambda, type ManifestStackHash, type ResourceMapEntry, type FjallManifest } from "./schemas.js";
+export { getManifestFilePath, readManifestFile, writeManifestFile, createEmptyManifest, readConstructMap, parseDockerServicesFromManifest, type ManifestDockerService } from "./io.js";

package/dist/manifest/index.js

@@ -0,0 +1 @@
+import{DockerBuildSchema as t,DockerBuildPartialSchema as r,mergeDockerBuild as i,ManifestServiceSchema as c,ManifestPatternSchema as M,ManifestEcrSchema as s,ManifestLambdaSchema as S,ManifestStackHashSchema as m,ResourceMapEntrySchema as n,FjallManifestSchema as f,FJALL_MANIFEST_FILENAME as h,MANIFEST_SCHEMA_VERSION as o}from"./schemas.js";import{getManifestFilePath as E,readManifestFile as F,writeManifestFile as d,createEmptyManifest as p,readConstructMap as k,parseDockerServicesFromManifest as u}from"./io.js";export{r as DockerBuildPartialSchema,t as DockerBuildSchema,h as FJALL_MANIFEST_FILENAME,f as FjallManifestSchema,o as MANIFEST_SCHEMA_VERSION,s as ManifestEcrSchema,S as ManifestLambdaSchema,M as ManifestPatternSchema,c as ManifestServiceSchema,m as ManifestStackHashSchema,n as ResourceMapEntrySchema,p as createEmptyManifest,E as getManifestFilePath,i as mergeDockerBuild,u as parseDockerServicesFromManifest,k as readConstructMap,F as readManifestFile,d as writeManifestFile};

package/dist/manifest/io.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Node-only I/O helpers for the Fjall manifest.
+ *
+ * This module imports `fs/promises` and `path` and is therefore Node-only.
+ * The pure schema/types live in the sibling `./schemas` module — consumers
+ * that need the docker-shape types without I/O (e.g. the generator) MUST
+ * import from `./schemas` directly.
+ */
+import { type DockerBuild, type FjallManifest, type ResourceMapEntry } from "./schemas.js";
+/**
+ * Get the manifest file path for a cdk.out directory.
+ */
+export declare function getManifestFilePath(cdkOutPath: string): string;
+/**
+ * Read manifest file from cdk.out directory.
+ * Returns null if file doesn't exist or is corrupt.
+ */
+export declare function readManifestFile(cdkOutPath: string): Promise<FjallManifest | null>;
+/**
+ * Write manifest file atomically using temp file + rename pattern.
+ */
+export declare function writeManifestFile(cdkOutPath: string, manifest: FjallManifest): Promise<void>;
+/**
+ * Create an empty manifest structure.
+ */
+export declare function createEmptyManifest(appName: string): FjallManifest;
+/**
+ * Read the construct map from the fjall-manifest.json file.
+ * Returns an empty map if the file doesn't exist, is malformed,
+ * or has no resourceMap section. Never throws.
+ */
+export declare function readConstructMap(cdkOutPath: string): Promise<Map<string, ResourceMapEntry>>;
+/**
+ * A service entry from the manifest with its `docker` block guaranteed present.
+ *
+ * Used by deploy-core to gate Docker pre-build steps. Entries without a
+ * `docker` block (e.g. lambda-only manifests, or future role types that
+ * carry no Dockerfile) are filtered out — the deploy-core call sites only
+ * care about the build set, so the parser narrows here.
+ */
+export interface ManifestDockerService {
+    readonly name: string;
+    readonly docker: DockerBuild;
+}
+/**
+ * Extract services with a Docker build configuration from the Fjall manifest.
+ *
+ * The manifest is the authoritative post-synth source for Docker
+ * configuration — `docker.path` may be absolute (cross-repo monorepo
+ * layouts) or relative to the app root, and a filesystem-only check
+ * cannot see absolute paths outside the app root.
+ *
+ * Returns an empty array if the manifest does not exist, cannot be parsed,
+ * or contains no Docker services. Never throws.
+ *
+ * Reads synchronously because deploy-core's call sites are inside synchronous
+ * orchestration loops; the file is small and sealed by CDK synth ahead of
+ * the deploy phase.
+ */
+export declare function parseDockerServicesFromManifest(cdkOutPath: string): ManifestDockerService[];

package/dist/manifest/io.js

@@ -0,0 +1 @@
+import{readFile as l,writeFile as m,unlink as h,rename as g,mkdir as M}from"fs/promises";import{readFileSync as y}from"fs";import{dirname as F,join as f}from"path";import{logger as s}from"../logger.js";import{fileExists as w}from"../fsHelpers.js";import{getErrorMessage as u}from"../errorUtils.js";import{recordToConstructMap as S}from"../constructMap.js";import{DockerBuildSchema as x,FjallManifestSchema as k,FJALL_MANIFEST_FILENAME as d,MANIFEST_SCHEMA_VERSION as A}from"./schemas.js";function p(e){return f(e,d)}async function E(e){const t=p(e);if(!await w(t))return null;try{const r=await l(t,"utf-8"),n=JSON.parse(r),a=k.safeParse(n);return a.success||s.debug("FjallManifest","Manifest validation failed",{path:t,errors:a.error.issues.map(i=>`${i.path.join(".")}: ${i.message}`)}),a.success?a.data:null}catch(r){return s.debug("FjallManifest","Failed to read manifest file",{path:t,error:u(r)}),null}}async function T(e,t){const r=p(e),n=`${r}.${Date.now()}.tmp`;await M(F(r),{recursive:!0});try{await m(n,JSON.stringify(t,null,2),"utf-8"),await g(n,r)}catch(a){try{await h(n)}catch(i){s.debug("FjallManifest","Temp file cleanup failed (non-fatal)",{path:n,error:u(i)})}throw a}}function _(e){return{version:A,generatedAt:new Date().toISOString(),appName:e,services:[],lambdas:[],stacks:{}}}async function $(e){const t=await E(e);return t?.resourceMap?S(t.resourceMap):new Map}function o(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function j(e){if(!o(e)||typeof e.path!="string"||e.path.length===0)return;const t=typeof e.context=="string"&&e.context.length>0?e.context:void 0,r=typeof e.target=="string"&&e.target.length>0?e.target:void 0,n={path:e.path,...t!==void 0&&{context:t},...r!==void 0&&{target:r}},a=x.safeParse(n);return a.success?a.data:void 0}function L(e){const t=f(e,d);let r;try{r=y(t,"utf-8")}catch{return s.debug("FjallManifest","Manifest file not readable \u2014 no Docker services extracted",{path:t}),[]}let n;try{n=JSON.parse(r)}catch{return s.debug("FjallManifest","Manifest is not valid JSON \u2014 no Docker services extracted",{path:t}),[]}if(!o(n)||!Array.isArray(n.services))return[];const a=[];for(const i of n.services){if(!o(i)||typeof i.name!="string")continue;const c=j(i.docker);c!==void 0&&a.push({name:i.name,docker:c})}return a}export{_ as createEmptyManifest,p as getManifestFilePath,L as parseDockerServicesFromManifest,$ as readConstructMap,E as readManifestFile,T as writeManifestFile};