@fjall/generator 0.88.4

package/dist/src/generation/storage.js

@@ -0,0 +1,174 @@
+/**
+ * Storage Code Generation
+ *
+ * Functions for generating storage infrastructure code including
+ * S3 buckets, DynamoDB tables, and SQS queues.
+ */
+import { buildProperty, getVariableName, emitExtraProperties, } from "./common.js";
+/**
+ * Generate S3 bucket configuration properties using buildProperty for consistent formatting
+ */
+function generateS3BucketProps(bucket) {
+    let code = "";
+    code += buildProperty(bucket.bucketName !== undefined, "bucketName", bucket.bucketName, "string");
+    code += buildProperty(bucket.stackPlacement !== undefined && bucket.stackPlacement !== "storage", "stackPlacement", bucket.stackPlacement, "string");
+    code += buildProperty(bucket.publicReadAccess === true, "publicReadAccess", true);
+    code += buildProperty(bucket.websiteHosting !== undefined, "websiteHosting", bucket.websiteHosting, "object");
+    code += buildProperty(bucket.backupVaultTier !== undefined, "backupVaultTier", bucket.backupVaultTier, "string");
+    code += buildProperty(bucket.versioned !== undefined, "versioned", bucket.versioned);
+    code += buildProperty(bucket.encryption !== undefined, "encryption", bucket.encryption, "string");
+    code += buildProperty(bucket.kmsKeyArn !== undefined, "kmsKeyArn", bucket.kmsKeyArn, "string");
+    code += buildProperty(bucket.cors !== undefined && bucket.cors.length > 0, "cors", bucket.cors, "object");
+    code += buildProperty(bucket.deployment !== undefined, "deployment", bucket.deployment, "object");
+    return code;
+}
+/**
+ * Check if an S3 bucket needs a variable assignment (referenced by compute or CDN)
+ */
+export function s3NeedsVariable(bucket, plan) {
+    // Referenced by compute via connectedStorage
+    const computeRef = plan.compute.some((compute) => compute.connectedStorage?.includes(bucket.name));
+    if (computeRef)
+        return true;
+    // Referenced by CDN as an origin
+    if (plan.cdn) {
+        if (plan.cdn.defaultOriginRef === bucket.name)
+            return true;
+        if (plan.cdn.behaviours?.some((b) => b.originRef === bucket.name))
+            return true;
+    }
+    return false;
+}
+/**
+ * Generate S3 bucket infrastructure code
+ */
+export function generateS3Code(plan) {
+    if (plan.s3.length === 0)
+        return "";
+    let code = "";
+    for (let i = 0; i < plan.s3.length; i++) {
+        const bucket = plan.s3[i];
+        const bucketVariable = getVariableName(bucket);
+        const hasReferences = s3NeedsVariable(bucket, plan);
+        const needsLeadingNewline = plan.database.length > 0 || i > 0;
+        const leadingNewline = needsLeadingNewline ? "\n" : "";
+        const props = generateS3BucketProps(bucket);
+        const prefix = hasReferences ? `const ${bucketVariable} = ` : "";
+        const extraPropsStr = emitExtraProperties(bucket.extraProperties);
+        if (props || extraPropsStr) {
+            code += `${leadingNewline}${prefix}app.addStorage(
+  StorageFactory.build("${bucket.name}", {${props}${extraPropsStr}
+  })
+);
+`;
+        }
+        else {
+            code += `${leadingNewline}${prefix}app.addStorage(
+  StorageFactory.build("${bucket.name}", {})
+);
+`;
+        }
+    }
+    return code;
+}
+/**
+ * Generate DynamoDB table infrastructure code
+ */
+export function generateDynamoDBCode(plan) {
+    if (!plan.dynamodb || plan.dynamodb.length === 0)
+        return "";
+    let code = "";
+    for (const table of plan.dynamodb) {
+        const tableVariable = getVariableName(table);
+        code += `
+const ${tableVariable} = app.addDatabase(
+  DatabaseFactory.build("${table.name}", {
+    type: "DynamoDB",
+    partitionKey: {
+      name: "${table.partitionKey.name}",
+      type: "${table.partitionKey.type}",
+    }`;
+        if (table.sortKey) {
+            code += `,
+    sortKey: {
+      name: "${table.sortKey.name}",
+      type: "${table.sortKey.type}",
+    }`;
+        }
+        if (table.globalSecondaryIndexes &&
+            table.globalSecondaryIndexes.length > 0) {
+            const gsiStr = table.globalSecondaryIndexes
+                .map((gsi) => {
+                let gsiCode = `{
+        indexName: "${gsi.indexName}",
+        partitionKey: {
+          name: "${gsi.partitionKey.name}",
+          type: "${gsi.partitionKey.type}",
+        },`;
+                if (gsi.sortKey) {
+                    gsiCode += `
+        sortKey: {
+          name: "${gsi.sortKey.name}",
+          type: "${gsi.sortKey.type}",
+        },`;
+                }
+                gsiCode += `
+      }`;
+                return gsiCode;
+            })
+                .join(",\n      ");
+            code += `,
+    globalSecondaryIndexes: [
+      ${gsiStr}
+    ]`;
+        }
+        if (table.ttlAttribute) {
+            code += `,
+    ttlAttribute: "${table.ttlAttribute}"`;
+        }
+        if (table.stream) {
+            code += `,
+    stream: true`;
+        }
+        code += emitExtraProperties(table.extraProperties);
+        code += `
+  })
+);
+`;
+    }
+    return code;
+}
+/**
+ * Generate SQS queue infrastructure code
+ */
+export function generateSQSCode(plan) {
+    if (!plan.sqs || plan.sqs.length === 0)
+        return "";
+    let code = "";
+    for (const queue of plan.sqs) {
+        const queueVariable = getVariableName(queue);
+        code += `
+const ${queueVariable} = app.addMessaging(
+  MessagingFactory.build("${queue.name}", {
+    type: "queue",
+    queueType: "${queue.queueType}"`;
+        if (queue.visibilityTimeout !== undefined) {
+            code += `,
+    visibilityTimeout: ${queue.visibilityTimeout}`;
+        }
+        if (queue.retentionPeriod !== undefined) {
+            code += `,
+    messageRetentionPeriod: ${queue.retentionPeriod}`;
+        }
+        if (queue.contentBasedDeduplication) {
+            code += `,
+    contentBasedDeduplication: true`;
+        }
+        code += emitExtraProperties(queue.extraProperties);
+        code += `
+  })
+);
+`;
+    }
+    return code;
+}

package/dist/src/generation/storageConnections.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Storage Connection Code Generation
+ *
+ * Functions for generating storage connection code (env vars, connections array)
+ * following the same pattern as database connections.
+ */
+import type { S3ResourcePlan, ApplicationResourcePlan, ComputeResourcePlan, DatabaseResourcePlan } from "../schemas/resourceSchemas.js";
+export declare const STORAGE_ENV_VARS: Readonly<{
+    readonly NAME: "BUCKET_NAME";
+}>;
+export type StorageEnvVarEntry = {
+    key: string;
+    expression: string;
+};
+export interface StorageEnvVars {
+    env: Record<string, unknown>;
+    secrets: Record<string, unknown>;
+}
+/**
+ * Get S3 buckets connected to a compute resource
+ */
+export declare function getConnectedStorage(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): S3ResourcePlan[];
+/**
+ * Generate storage environment variable entries for a list of connected buckets.
+ * S3 uses IAM-based access, so there are no secrets — only BUCKET_NAME env vars.
+ */
+export declare function generateStorageEnvVarEntries(connectedStorage: S3ResourcePlan[]): StorageEnvVarEntry[];
+/**
+ * Build storage environment variables for a compute resource.
+ * S3 always uses IAM — secrets is always empty.
+ */
+export declare function buildStorageEnvVars(plan: ApplicationResourcePlan, compute: ComputeResourcePlan): StorageEnvVars;
+/**
+ * Format combined connections array for generated infrastructure code.
+ * Merges both database and storage variable names into a single connections line.
+ */
+export declare function formatAllConnectionsCode(connectedDatabases: DatabaseResourcePlan[], connectedStorage: S3ResourcePlan[]): string;

package/dist/src/generation/storageConnections.js

@@ -0,0 +1,71 @@
+/**
+ * Storage Connection Code Generation
+ *
+ * Functions for generating storage connection code (env vars, connections array)
+ * following the same pattern as database connections.
+ */
+import { getVariableName } from "./common.js";
+export const STORAGE_ENV_VARS = Object.freeze({
+    NAME: "BUCKET_NAME",
+});
+/**
+ * Get S3 buckets connected to a compute resource
+ */
+export function getConnectedStorage(plan, compute) {
+    const { connectedStorage } = compute;
+    if (!connectedStorage?.length)
+        return [];
+    return plan.s3.filter((bucket) => connectedStorage.includes(bucket.name));
+}
+/**
+ * Generate storage environment variable entries for a list of connected buckets.
+ * S3 uses IAM-based access, so there are no secrets — only BUCKET_NAME env vars.
+ */
+export function generateStorageEnvVarEntries(connectedStorage) {
+    const entries = [];
+    if (connectedStorage.length === 1) {
+        const bucketVar = getVariableName(connectedStorage[0]);
+        entries.push({
+            key: STORAGE_ENV_VARS.NAME,
+            expression: `${bucketVar}.getBucketName()`,
+        });
+    }
+    else {
+        for (const [index, bucket] of connectedStorage.entries()) {
+            const bucketVar = getVariableName(bucket);
+            const suffix = index === 0 ? "" : `_${index + 1}`;
+            entries.push({
+                key: `${STORAGE_ENV_VARS.NAME}${suffix}`,
+                expression: `${bucketVar}.getBucketName()`,
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Build storage environment variables for a compute resource.
+ * S3 always uses IAM — secrets is always empty.
+ */
+export function buildStorageEnvVars(plan, compute) {
+    const env = {};
+    const secrets = {};
+    if (!compute.connectedStorage?.length) {
+        return { env, secrets };
+    }
+    const connectedStorage = getConnectedStorage(plan, compute);
+    const entries = generateStorageEnvVarEntries(connectedStorage);
+    for (const entry of entries) {
+        env[entry.key] = { __expression: entry.expression };
+    }
+    return { env, secrets };
+}
+/**
+ * Format combined connections array for generated infrastructure code.
+ * Merges both database and storage variable names into a single connections line.
+ */
+export function formatAllConnectionsCode(connectedDatabases, connectedStorage) {
+    const dbVars = connectedDatabases.map((db) => getVariableName(db));
+    const storageVars = connectedStorage.map((b) => getVariableName(b));
+    const allVars = [...dbVars, ...storageVars].join(", ");
+    return `connections: [${allVars}],`;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export { normaliseError, getErrorMessage } from "./util/errorUtils.js";
+export { type Result, isSuccess, isFailure, success, failure, tryAsync, trySync, } from "./types/Result.js";
+export { VALIDATION_PATTERNS, VALIDATION_MESSAGES, type ValidationPatternKey, type ValidationMessageKey, } from "./validation/patterns.js";
+export { type RegionInfo, DEFAULT_REGION, regions, AWS_REGIONS_METADATA, topRegions, commonRegions, parseRegionList, isValidRegion, isValidRegionFormat, getSuggestions, validateRegion, validateRegionList, filterDuplicateRegions, getRegionOptions, getRegionOptionsExcluding, getRegionName, createRegionFormatter, } from "./aws/regions.js";
+export { GENERATOR_VERSION } from "./version.js";
+export * from "./schemas/index.js";
+export * from "./generation/index.js";
+export * from "./presets/index.js";
+export * from "./ast/index.js";
+export * from "./planning/index.js";

package/dist/src/index.js

@@ -0,0 +1,19 @@
+// Utility foundation
+export { normaliseError, getErrorMessage } from "./util/errorUtils.js";
+export { isSuccess, isFailure, success, failure, tryAsync, trySync, } from "./types/Result.js";
+// Validation
+export { VALIDATION_PATTERNS, VALIDATION_MESSAGES, } from "./validation/patterns.js";
+// AWS
+export { DEFAULT_REGION, regions, AWS_REGIONS_METADATA, topRegions, commonRegions, parseRegionList, isValidRegion, isValidRegionFormat, getSuggestions, validateRegion, validateRegionList, filterDuplicateRegions, getRegionOptions, getRegionOptionsExcluding, getRegionName, createRegionFormatter, } from "./aws/regions.js";
+// Version
+export { GENERATOR_VERSION } from "./version.js";
+// Schemas, plan types, constants
+export * from "./schemas/index.js";
+// Code generation
+export * from "./generation/index.js";
+// Tier, pattern, and storage presets
+export * from "./presets/index.js";
+// AST parsing & surgical modification
+export * from "./ast/index.js";
+// Resource planning
+export * from "./planning/index.js";

package/dist/src/planning/index.d.ts

@@ -0,0 +1 @@
+export { planApplicationResources, type OpenNextResourceOptions, planOpenNextResources, type GenerationOptions, generateInfrastructureFromPlan, } from "./resourcePlanning.js";

package/dist/src/planning/index.js

@@ -0,0 +1 @@
+export { planApplicationResources, planOpenNextResources, generateInfrastructureFromPlan, } from "./resourcePlanning.js";

package/dist/src/planning/resourcePlanning.d.ts

@@ -0,0 +1,58 @@
+import { type UserServiceConfig, type AppType } from "../presets/tierPresets.js";
+import { type PatternTypeWithCustom } from "../presets/patternTierPresets.js";
+import { type PatternType } from "../schemas/constants.js";
+import { type Result } from "../types/Result.js";
+import type { ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+export declare function planApplicationResources(appName: string, appType: AppType, includeDatabase?: boolean, services?: UserServiceConfig[], snapshotOptions?: {
+    snapshotIdentifier?: string;
+    snapshotUsername?: string;
+}): ApplicationResourcePlan;
+export interface OpenNextResourceOptions {
+    /** Pattern tier: lightweight, standard, resilient, or custom */
+    tier?: PatternTypeWithCustom;
+    /** Custom domain (auto-creates certificate + DNS) */
+    domain?: string;
+    /** Database configuration (uses tier defaults if not specified) */
+    database?: {
+        type?: "Instance" | "Aurora";
+        instanceType?: string;
+        databaseName?: string;
+        publiclyAccessible?: boolean;
+        allowedIpCidr?: string;
+        backupRetention?: number;
+        deletionProtection?: boolean;
+        encryption?: {
+            useCMK: true;
+        } | false;
+    };
+    /** Compute (Lambda) configuration (uses tier defaults if not specified) */
+    compute?: {
+        memorySize?: number;
+        timeout?: number;
+    };
+    /** CDN configuration (advanced - prefer `domain` for simple setup) */
+    cdn?: {
+        domainNames?: string[];
+        certificateArn?: string;
+    };
+    /** Additional environment variables */
+    environment?: Record<string, string>;
+    /** Resource tags */
+    tags?: Record<string, string>;
+}
+/**
+ * Plan resources for OpenNext patterns (Next.js/Payload).
+ *
+ * All OpenNext patterns use the PatternFactory approach, generating a single
+ * `PatternFactory.build()` call. The pattern class internally handles all
+ * infrastructure (database, S3, DynamoDB, SQS, Lambdas, CDN).
+ *
+ * @example
+ * const plan = planOpenNextResources("my-cms", "payload", { tier: "standard" });
+ */
+export declare function planOpenNextResources(appName: string, pattern: PatternType, options?: OpenNextResourceOptions): Result<ApplicationResourcePlan, Error>;
+export interface GenerationOptions {
+    /** Resource name mapping from old names to new names (for custom code repositioning) */
+    resourceMapping?: Map<string, string>;
+}
+export declare function generateInfrastructureFromPlan(plan: ApplicationResourcePlan, options?: GenerationOptions): Result<string, Error>;

package/dist/src/planning/resourcePlanning.js

@@ -0,0 +1,216 @@
+import { TIER_PRESETS, getDefaultDatabaseTypeForTier, getNetworkPreset, applyTierDefaultsToServices, } from "../presets/tierPresets.js";
+import { getPatternTierPreset, isPatternTierName, } from "../presets/patternTierPresets.js";
+import { COMPUTE_TYPE } from "../schemas/constants.js";
+import { success, failure } from "../types/Result.js";
+import { PatternConfigSchema } from "../schemas/resourceSchemas.js";
+import { injectCustomCodeBlocks } from "../ast/astSurgicalModification.js";
+import { toVariableName, toValidDatabaseName, generateImports, generateAppInit, generateTags, generateNetworkCode, generateDatabaseCode, generateS3Code, generateDynamoDBCode, generateSQSCode, generateComputeCode, generateCDNCode, collectCdnReferencedResources, usesPatternApproach, generatePatternCodeWithComments, } from "../generation/index.js";
+const DEFAULT_NETWORK = getNetworkPreset("standard");
+/** Type guard that narrows a pattern string to a supported PatternConfig type via Zod schema. */
+function isPatternConfigType(value) {
+    return PatternConfigSchema.options.some((schema) => schema.shape?.type?.value === value);
+}
+export function planApplicationResources(appName, appType, includeDatabase = true, services, snapshotOptions) {
+    const basePlan = {
+        appName,
+        type: appType,
+        database: [],
+        s3: [],
+        compute: [],
+        importedResources: [],
+    };
+    if (appType === "custom") {
+        return basePlan;
+    }
+    const tier = appType;
+    const tierPreset = TIER_PRESETS[tier];
+    return {
+        ...basePlan,
+        database: buildDatabasePlan(appName, tierPreset, tier, includeDatabase, snapshotOptions),
+        compute: buildComputePlan(appName, tierPreset, tier, includeDatabase, services),
+        network: tierPreset.network,
+        backup: tierPreset.backup,
+    };
+}
+function buildDatabasePlan(appName, tierPreset, tier, includeDatabase, snapshotOptions) {
+    const databaseType = getDefaultDatabaseTypeForTier(tier);
+    const databasePreset = tierPreset.database[databaseType];
+    if (!includeDatabase || databasePreset === null)
+        return [];
+    return [
+        {
+            name: appName,
+            type: databaseType,
+            databaseName: toValidDatabaseName(appName),
+            variableName: `${toVariableName(appName)}Database`,
+            ...databasePreset,
+            ...(snapshotOptions?.snapshotIdentifier !== undefined && {
+                snapshotIdentifier: snapshotOptions.snapshotIdentifier,
+            }),
+            ...(snapshotOptions?.snapshotUsername !== undefined && {
+                snapshotUsername: snapshotOptions.snapshotUsername,
+            }),
+        },
+    ];
+}
+function buildScalingConfig(minCapacity, maxCapacity) {
+    if (minCapacity === undefined && maxCapacity === undefined)
+        return undefined;
+    return {
+        scaling: {
+            ...(minCapacity !== undefined && { minCapacity }),
+            ...(maxCapacity !== undefined && { maxCapacity }),
+        },
+    };
+}
+function buildServiceEntry(tierService, userService) {
+    const { minCapacity, maxCapacity, ...rest } = tierService;
+    const containerPort = userService?.containerPort ?? 3000;
+    return {
+        ...rest,
+        dockerfilePath: userService?.dockerfilePath,
+        needsDatabaseConnection: userService?.needsDatabaseConnection,
+        containers: [{ port: containerPort }],
+        ...buildScalingConfig(minCapacity, maxCapacity),
+    };
+}
+function buildComputePlan(appName, tierPreset, tier, includeDatabase, services) {
+    const ecsPreset = tierPreset.compute.ecs;
+    const tierServices = services && services.length > 0
+        ? applyTierDefaultsToServices(tier, services)
+        : ecsPreset.services.map((s, i) => ({
+            ...s,
+            name: i === 0 ? "api" : `service-${i + 1}`,
+        }));
+    return [
+        {
+            name: appName,
+            type: COMPUTE_TYPE.ECS,
+            needsConnection: includeDatabase,
+            connectedDatabase: includeDatabase ? [appName] : undefined,
+            variableName: `${toVariableName(appName)}Compute`,
+            cluster: ecsPreset.cluster,
+            services: tierServices.map((tierService, index) => buildServiceEntry(tierService, services?.[index])),
+        },
+    ];
+}
+/**
+ * Plan resources for OpenNext patterns (Next.js/Payload).
+ *
+ * All OpenNext patterns use the PatternFactory approach, generating a single
+ * `PatternFactory.build()` call. The pattern class internally handles all
+ * infrastructure (database, S3, DynamoDB, SQS, Lambdas, CDN).
+ *
+ * @example
+ * const plan = planOpenNextResources("my-cms", "payload", { tier: "standard" });
+ */
+export function planOpenNextResources(appName, pattern, options) {
+    const { tier = "standard", domain, database, compute, cdn, environment, tags, } = options ?? {};
+    const validTier = isPatternTierName(tier);
+    if (!validTier && tier !== "custom") {
+        return failure(new Error(`Invalid pattern tier: "${tier}". Valid tiers are: lightweight, standard, resilient, custom`));
+    }
+    if (!isPatternConfigType(pattern)) {
+        return failure(new Error(`Unsupported pattern type: ${pattern}`));
+    }
+    const tierPreset = validTier ? getPatternTierPreset(tier) : null;
+    const patternConfig = buildPatternConfig(pattern, appName, {
+        domain,
+        database,
+        compute,
+        cdn,
+        environment,
+        tierPreset,
+    });
+    if (patternConfig instanceof Error) {
+        return failure(patternConfig);
+    }
+    return success({
+        appName,
+        type: "standard",
+        pattern,
+        network: tierPreset ? tierPreset.network : DEFAULT_NETWORK,
+        backup: tierPreset ? tierPreset.backup : false,
+        patternConfig,
+        database: [],
+        s3: [],
+        compute: [],
+        tags: tags ?? {},
+        importedResources: [],
+    });
+}
+function mergeDatabaseConfig(database, tierPreset) {
+    return {
+        type: database?.type ?? tierPreset.database.type,
+        instanceType: database?.instanceType ?? tierPreset.database.instanceType,
+        databaseName: database?.databaseName,
+        publiclyAccessible: database?.publiclyAccessible,
+        allowedIpCidr: database?.allowedIpCidr,
+        backupRetention: database?.backupRetention ?? tierPreset.database.backupRetention,
+        deletionProtection: database?.deletionProtection ?? tierPreset.database.deletionProtection,
+        encryption: database?.encryption,
+    };
+}
+function mergeComputeConfig(compute, tierPreset) {
+    return {
+        memorySize: compute?.memorySize ?? tierPreset.compute.memorySize,
+        timeout: compute?.timeout ?? tierPreset.compute.timeout,
+    };
+}
+function toPatternDatabaseConfig(db) {
+    const { encryption, ...rest } = db;
+    return {
+        ...rest,
+        ...(encryption && { encryption: { storageKey: encryption } }),
+    };
+}
+function buildPatternConfig(type, appName, opts) {
+    const { domain, database, compute, cdn, environment, tierPreset } = opts;
+    const mergedDatabase = tierPreset
+        ? mergeDatabaseConfig(database, tierPreset)
+        : database;
+    const mergedCompute = tierPreset
+        ? mergeComputeConfig(compute, tierPreset)
+        : compute;
+    const config = {
+        type,
+        name: appName,
+        domain,
+        database: mergedDatabase
+            ? toPatternDatabaseConfig(mergedDatabase)
+            : undefined,
+        compute: mergedCompute ? { server: mergedCompute } : undefined,
+        cdn: cdn
+            ? { domainNames: cdn.domainNames, certificateArn: cdn.certificateArn }
+            : undefined,
+        environment,
+    };
+    const result = PatternConfigSchema.safeParse(config);
+    if (!result.success) {
+        return new Error(`Invalid pattern config: ${result.error.message}`);
+    }
+    return result.data;
+}
+export function generateInfrastructureFromPlan(plan, options) {
+    const parts = [
+        generateImports(plan),
+        generateAppInit(plan),
+        generateTags(plan),
+    ];
+    if (usesPatternApproach(plan)) {
+        parts.push(generatePatternCodeWithComments(plan), generateNetworkCode(plan));
+    }
+    else {
+        const cdnReferencedResources = collectCdnReferencedResources(plan);
+        parts.push(generateNetworkCode(plan), generateDatabaseCode(plan), generateS3Code(plan), generateDynamoDBCode(plan), generateSQSCode(plan), generateComputeCode(plan, cdnReferencedResources), generateCDNCode(plan));
+    }
+    const code = parts.join("");
+    if (plan.customCodeBlocks && plan.customCodeBlocks.length > 0) {
+        const injectionResult = injectCustomCodeBlocks(code, plan.customCodeBlocks, options?.resourceMapping);
+        if (!injectionResult.success) {
+            return failure(new Error(`Custom code injection failed: ${injectionResult.error ?? "unknown error"}`));
+        }
+        return success(injectionResult.content);
+    }
+    return success(code);
+}

package/dist/src/presets/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./tierPresets.js";
+export { PATTERN_TIER_NAMES, type PatternTierName, PATTERN_TYPES_WITH_CUSTOM, type PatternTypeWithCustom, type PatternDatabasePreset, type PatternComputePreset, type PatternTierPreset, PATTERN_TIER_PRESETS, getPatternTierPreset, getPatternTierOptions, isPatternTierName, } from "./patternTierPresets.js";
+export { type StoragePreset, STORAGE_PRESETS, getStoragePreset, getStoragePresetOptions, } from "./storagePresets.js";

package/dist/src/presets/index.js

@@ -0,0 +1,3 @@
+export * from "./tierPresets.js";
+export { PATTERN_TIER_NAMES, PATTERN_TYPES_WITH_CUSTOM, PATTERN_TIER_PRESETS, getPatternTierPreset, getPatternTierOptions, isPatternTierName, } from "./patternTierPresets.js";
+export { STORAGE_PRESETS, getStoragePreset, getStoragePresetOptions, } from "./storagePresets.js";