@empire-builder-kit/nx 1.0.0-beta.9 → 1.0.0-rc.2

package/src/generators/slice/built-in-plan-operations-files.js

@@ -0,0 +1,630 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSliceOperationsFiles = renderSliceOperationsFiles;
+const index_js_1 = require("../../ownership/index.js");
+const feature_registry_js_1 = require("../feature-registry.js");
+const logging_registry_js_1 = require("../logging-registry.js");
+const built_in_plan_shared_js_1 = require("./built-in-plan-shared.js");
+/** @internal */
+function renderSliceOperationsFiles(name, workspace = 'workspace', frameworkVersion = 'workspace-installed') {
+    return {
+        'operations/features.json': (0, built_in_plan_shared_js_1.json)({
+            features: [
+                {
+                    description: 'Authentication and protected-access behavior.',
+                    id: 'authorization',
+                },
+                {
+                    description: 'Queues, schedules, webhooks, provider delivery, and durable workflow behavior.',
+                    id: 'async-work',
+                },
+                {
+                    description: 'Typed local and deployed dynamic configuration behavior.',
+                    id: 'configuration',
+                },
+                {
+                    description: 'Logical database health and lifecycle behavior.',
+                    id: 'database',
+                },
+                {
+                    description: 'Database bootstrap, migration, and protected retirement behavior.',
+                    id: 'database-lifecycle',
+                },
+                {
+                    description: 'Retention, export, correction, deletion, and hold behavior.',
+                    id: 'data-lifecycle',
+                },
+                {
+                    description: 'Published and consumed domain-event behavior.',
+                    id: 'events',
+                },
+                {
+                    description: 'Server/client boundaries, rendered-state accessibility, browser security, and visual evidence.',
+                    id: 'frontend',
+                },
+                {
+                    description: 'Health and operator-facing runtime behavior.',
+                    id: 'operations',
+                },
+                {
+                    description: 'Infrastructure planning, drift, approval, and convergence behavior.',
+                    id: 'infrastructure-change',
+                },
+                {
+                    description: 'Performance budgets, capacity limits, protected load, cost, and resource attribution.',
+                    id: 'performance',
+                },
+                {
+                    description: 'Immutable release, rollout, rollback, and cleanup behavior.',
+                    id: 'release',
+                },
+                {
+                    description: 'Service objectives, alarms, incidents, diagnostics, and recovery behavior.',
+                    id: 'reliability',
+                },
+                {
+                    description: 'Server-rendered web and authentication routes.',
+                    id: 'web',
+                },
+            ],
+            schemaVersion: feature_registry_js_1.SLICE_FEATURE_REGISTRY_SCHEMA_VERSION,
+        }),
+        'operations/log-queries.json': (0, built_in_plan_shared_js_1.json)({
+            queries: [
+                {
+                    id: 'scoped-errors',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId | filter slice = ?slice and feature = ?feature and component = ?component and level in ["ERROR", "FATAL"] | sort @timestamp desc | limit 100',
+                    required: ['slice', 'feature', 'component'],
+                },
+                {
+                    id: 'correlation',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId, requestId, eventId | filter correlationId = ?correlationId | sort @timestamp asc | limit 200',
+                    required: ['correlationId'],
+                },
+                {
+                    id: 'event',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId, eventId, eventType | filter eventId = ?eventId | sort @timestamp asc | limit 200',
+                    required: ['eventId'],
+                },
+                {
+                    id: 'slow-successes',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId, attributes.durationMs | filter outcome = "success" and attributes.durationMs >= ?durationMs | sort attributes.durationMs desc | limit 100',
+                    required: ['durationMs'],
+                },
+                {
+                    id: 'grouped-failures',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome | filter outcome = "failure" or level in ["ERROR", "FATAL"] | stats count() as failureCount by operation | sort failureCount desc | limit 100',
+                    required: [],
+                },
+                {
+                    id: 'data-protection-findings',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome | filter ispresent(@dataProtection) | sort @timestamp desc | limit 100',
+                    required: [],
+                },
+                {
+                    id: 'database-lifecycle',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId, attributes.lifecycleEvent, attributes.databaseLifecycleId | filter feature = "database-lifecycle" | sort @timestamp asc | limit 200',
+                    required: [],
+                },
+                {
+                    id: 'async-recovery',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, message, outcome, correlationId, eventId, attributes.recoveryId, attributes.reportDigest | filter feature = "async-work" | sort @timestamp asc | limit 200',
+                    required: [],
+                },
+                {
+                    id: 'configuration-evaluation',
+                    query: 'fields @timestamp, level, slice, feature, component, operation, outcome, attributes.provider, attributes.reason | filter feature = "configuration" | stats count() as evaluationCount by component, operation, outcome, attributes.provider, attributes.reason | limit 100',
+                    required: [],
+                },
+            ],
+            schemaVersion: 1,
+        }),
+        'operations/logging-components.json': (0, built_in_plan_shared_js_1.json)({
+            components: [
+                'api-health',
+                'api-protected',
+                'async-provider-delivery',
+                'async-recovery',
+                'async-schedule',
+                'async-webhook',
+                'async-workflow',
+                'authorization-delegations',
+                'data-rights',
+                'data-retention-review',
+                'database-health',
+                'database-records',
+                'event-consumer',
+                'event-publisher',
+                'configuration-evaluator',
+                'job-data-export-cleanup',
+                'job-data-retention',
+                'job-data-retention-maintenance',
+                'job-data-retention-maintenance-launcher',
+                'job-data-retention-orchestration',
+                'machine-client-provisioner',
+                'machine-authorization-proof',
+                'machine-authorization-proof-target',
+                'next-image-optimizer',
+                'next-revalidation-seeder',
+                'next-revalidation-subscriber',
+                'next-server',
+            ],
+            databaseComponents: [
+                'database-bootstrap',
+                'database-migration',
+                'database-migration-orchestration',
+                'database-retirement',
+                'database-retirement-orchestration',
+            ],
+            schemaVersion: logging_registry_js_1.SLICE_LOGGING_REGISTRY_SCHEMA_VERSION,
+        }),
+        'docs/runbooks/log-investigation.md': `# Log investigation
+
+Start with the generated \`operations/log-queries.json\` templates and the exact
+\`/ebk/<stage>/${name}/<component>[/<resource>]\` log-group prefix. Keep the time
+range and selected groups bounded. Supply only validated correlation or event
+identifiers; do not interpolate arbitrary Logs Insights syntax.
+
+The normal metadata observer cannot read protected raw logs. A separately
+authorized diagnostic investigator may run a bounded, attributable query.
+Unmasking data-protection findings is a different break-glass authority and is
+not implied by query access. Retained evidence contains the sanitized query
+plan, selected group names, time range, scanned bytes, and redacted findings,
+not raw records.
+
+Use \`scoped-errors\` for one registered feature/component, \`correlation\` for
+HTTP, Next.js, Service, Job, and event flow, \`event\` for
+publisher-to-consumer delivery, \`slow-successes\` for latency investigation,
+\`grouped-failures\` for terminal runtime failure trends, and
+\`data-protection-findings\` for detector metadata without matching content.
+Use \`database-lifecycle\` for bootstrap, migration, and protected retirement.
+Resolve ownership through \`operations/features.json\`, then follow the feature
+runbook. Do not treat an empty query result as incident resolution.
+`,
+        'scripts/verify-slice.mjs': `import { readFileSync } from 'node:fs';
+
+const ownership = JSON.parse(
+  readFileSync(new URL('../.ebk/ownership.json', import.meta.url), 'utf8'),
+);
+if (ownership.schemaVersion !== ${index_js_1.GENERATED_OWNERSHIP_SCHEMA_VERSION} || ownership.slice !== '${name}') {
+  throw new Error('Slice ownership metadata is missing or incompatible.');
+}
+if (!ownership.foundation.capabilities.includes('deployment')) {
+  throw new Error('Slice does not declare the Foundation deployment capability.');
+}
+const databaseBindings = JSON.parse(
+  readFileSync(new URL('../database/bindings.json', import.meta.url), 'utf8'),
+);
+const featureRegistry = JSON.parse(
+  readFileSync(new URL('../operations/features.json', import.meta.url), 'utf8'),
+);
+const asyncContract = JSON.parse(
+  readFileSync(
+    new URL('../async/work-contract.json', import.meta.url),
+    'utf8',
+  ),
+);
+const configurationDeclarations = JSON.parse(
+  readFileSync(
+    new URL('../configuration/declarations.json', import.meta.url),
+    'utf8',
+  ),
+);
+const infrastructureChange = JSON.parse(
+  readFileSync(
+    new URL('../operations/infrastructure-change.json', import.meta.url),
+    'utf8',
+  ),
+);
+const frontend = JSON.parse(
+  readFileSync(new URL('../frontend/contract.json', import.meta.url), 'utf8'),
+);
+const performance = JSON.parse(
+  readFileSync(
+    new URL('../operations/performance.json', import.meta.url),
+    'utf8',
+  ),
+);
+const release = JSON.parse(
+  readFileSync(new URL('../operations/release.json', import.meta.url), 'utf8'),
+);
+const reliability = JSON.parse(
+  readFileSync(
+    new URL('../operations/reliability.json', import.meta.url),
+    'utf8',
+  ),
+);
+for (const [label, document] of [
+  ['async work', asyncContract],
+  ['configuration', configurationDeclarations],
+  ['frontend', frontend],
+  ['infrastructure change', infrastructureChange],
+  ['performance', performance],
+  ['release', release],
+  ['reliability', reliability],
+]) {
+  if (
+    document?.schemaVersion !== 1 ||
+    document?.slice !== '${name}'
+  ) {
+    throw new Error(label + ' descriptor is missing or incompatible.');
+  }
+}
+const hasDatabaseBinding =
+  databaseBindings &&
+  typeof databaseBindings === 'object' &&
+  !Array.isArray(databaseBindings) &&
+  Object.keys(databaseBindings).length > 0;
+const hasDatabaseLifecycleFeature =
+  featureRegistry?.schemaVersion === ${feature_registry_js_1.SLICE_FEATURE_REGISTRY_SCHEMA_VERSION} &&
+  Array.isArray(featureRegistry.features) &&
+  featureRegistry.features.some(
+    (feature) => feature?.id === 'database-lifecycle',
+  );
+if (hasDatabaseBinding && !hasDatabaseLifecycleFeature) {
+  throw new Error(
+    'A Slice with a database binding must retain the database-lifecycle feature.',
+  );
+}
+process.stdout.write('${name} slice source contract verified.\\n');
+`,
+        'scripts/verify-live-mode.mjs': `const origin = process.env.EBK_FLEET_ORIGIN?.trim();
+if (origin) {
+  const parsed = new URL(origin);
+  const supportedHostname = parsed.hostname.endsWith('.ebk.localhost') || parsed.hostname.endsWith('.test');
+  if (parsed.protocol !== 'https:' || parsed.origin !== origin || !supportedHostname) {
+    throw new Error('EBK_FLEET_ORIGIN must be an exact HTTPS *.ebk.localhost or adopter-managed *.test origin.');
+  }
+  if (process.env.EBK_SECURE_COOKIES !== 'true') {
+    throw new Error('Fleet development requires EBK_SECURE_COOKIES=true.');
+  }
+}
+process.stdout.write('${name} live-mode prerequisites verified.\\n');
+`,
+        'scripts/check-database.mjs': `import { existsSync, readFileSync } from 'node:fs';
+import { createDatabaseBindingPlan } from '@empire-builder-kit/nx/foundation';
+import databaseBindings from '../database/bindings.json' with { type: 'json' };
+
+const migration = new URL('../database/migrations/0000_initial.sql', import.meta.url);
+if (!existsSync(migration) || !readFileSync(migration, 'utf8').includes('CREATE TABLE')) {
+  throw new Error('The initial database migration is missing or invalid.');
+}
+const plan = createDatabaseBindingPlan(databaseBindings, {
+  slice: '${name}',
+  stage: process.env.EBK_STAGE ?? 'development',
+});
+if (!plan.active.primary) throw new Error('Database binding "primary" is required.');
+process.stdout.write('${name} database history verified.\\n');
+`,
+        'scripts/local-database.mjs': `import { spawnSync } from 'node:child_process';
+import { createDatabaseBindingPlan, resolveLocalDatabaseContract } from '@empire-builder-kit/nx/foundation';
+import databaseBindings from '../database/bindings.json' with { type: 'json' };
+
+const action = process.argv[2];
+if (action !== 'up' && action !== 'down') {
+  throw new Error('Usage: node scripts/local-database.mjs <up|down>');
+}
+const plan = createDatabaseBindingPlan(databaseBindings, {
+  slice: '${name}',
+  stage: 'development',
+});
+const activeDatabase = plan.active.primary;
+if (!activeDatabase) throw new Error('Database binding "primary" is required.');
+const local = resolveLocalDatabaseContract({
+  database: activeDatabase,
+  slice: '${name}',
+});
+const project = process.env.COMPOSE_PROJECT_NAME ?? ('ebk-${name}-' + activeDatabase)
+  .replace(/[^a-z0-9_-]/g, '_')
+  .toLowerCase();
+const args = ['compose', '--project-name', project, '-f', 'database/docker-compose.yml'];
+args.push(...(action === 'up' ? ['up', '-d', '--wait'] : ['down']));
+const result = spawnSync('docker', args, {
+  env: {
+    ...process.env,
+    EBK_LOCAL_DATABASE: local.database,
+    EBK_LOCAL_DATABASE_PASSWORD: local.password,
+    EBK_LOCAL_DATABASE_PORT: String(local.port),
+    EBK_LOCAL_DATABASE_USERNAME: local.username,
+  },
+  stdio: 'inherit',
+});
+if (result.error) throw result.error;
+if (result.status !== 0) process.exit(result.status ?? 1);
+`,
+        'scripts/confirm-deploy.mjs': `const stageArg = process.argv.find((value) => value.startsWith('--stage='));
+const stage = stageArg?.slice('--stage='.length) ?? 'development';
+process.stdout.write('${name} infrastructure and database migrations completed for ' + stage + '.\\n');
+`,
+        'scripts/migrate-database.mjs': `import { createHash } from 'node:crypto';
+import {
+  DescribeExecutionCommand,
+  SFNClient,
+  StartExecutionCommand,
+} from '@aws-sdk/client-sfn';
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+import {
+  createDatabaseBindingPlan,
+  productSliceMigrationPath,
+  resolveFoundationStages,
+  selectDatabaseTarget,
+} from '@empire-builder-kit/nx/foundation';
+import databaseBindings from '../database/bindings.json' with { type: 'json' };
+
+const stageArg = process.argv.find((value) => value.startsWith('--stage='));
+const foundationStageArg = process.argv.find((value) =>
+  value.startsWith('--foundationStage='),
+);
+const { consumerStage: stage, foundationStage } = resolveFoundationStages({
+  consumerStage: stageArg?.slice('--stage='.length) ?? 'development',
+  foundationStage:
+    foundationStageArg?.slice('--foundationStage='.length) ??
+    process.env.EBK_FOUNDATION_STAGE,
+});
+const bindingPlan = createDatabaseBindingPlan(databaseBindings, {
+  slice: '${name}',
+  stage,
+});
+const databaseArg = process.argv.find((value) =>
+  value.startsWith('--database='),
+);
+const selectedDatabase = selectDatabaseTarget(bindingPlan, {
+  database: databaseArg?.slice('--database='.length),
+});
+
+const parameterName = productSliceMigrationPath(
+  foundationStage,
+  stage,
+  '${name}',
+  selectedDatabase,
+);
+const parameter = await new SSMClient({}).send(
+  new GetParameterCommand({ Name: parameterName }),
+);
+const stateMachineArn = parameter.Parameter?.Value;
+if (!stateMachineArn) {
+  throw new Error(
+    'Database migration state machine ARN is missing at ' +
+      parameterName +
+      '. Deploy Slice infrastructure before running migrations.',
+  );
+}
+
+const sourceCommit = (
+  process.env.GITHUB_SHA ??
+  process.env.EBK_SOURCE_COMMIT ??
+  'local'
+).replace(/[^A-Za-z0-9_-]/g, '-');
+const runIdentity = (
+  process.env.GITHUB_RUN_ID ??
+  process.env.EBK_MIGRATION_RUN_ID ??
+  String(Date.now())
+).replace(/[^A-Za-z0-9_-]/g, '-');
+const runAttempt = (
+  process.env.GITHUB_RUN_ATTEMPT ??
+  '1'
+).replace(/[^A-Za-z0-9_-]/g, '-');
+if (!/^\\d+$/.test(runAttempt)) {
+  throw new Error('GITHUB_RUN_ATTEMPT must be a positive integer.');
+}
+const parsedRunAttempt = Number.parseInt(runAttempt, 10);
+if (!Number.isSafeInteger(parsedRunAttempt) || parsedRunAttempt < 1) {
+  throw new Error('GITHUB_RUN_ATTEMPT must be a positive integer.');
+}
+const executionIdentity = createHash('sha256')
+  .update([
+    '${name}',
+    selectedDatabase,
+    runIdentity,
+    sourceCommit,
+  ].join('\\0'))
+  .digest('hex')
+  .slice(0, 16);
+const baseExecutionName = [
+  'ebk',
+  '${name}'.slice(0, 20),
+  selectedDatabase.slice(0, 20),
+  executionIdentity,
+].join('-').slice(0, 80);
+const databaseLifecycleCorrelationId =
+  'dbm-' + executionIdentity + '-' + runAttempt;
+const sfn = new SFNClient({});
+const executionArnFor = (name) =>
+  stateMachineArn.replace(':stateMachine:', ':execution:') + ':' + name;
+const describeExecution = async (name) => {
+  try {
+    return await sfn.send(
+      new DescribeExecutionCommand({ executionArn: executionArnFor(name) }),
+    );
+  } catch (error) {
+    if (
+      error &&
+      typeof error === 'object' &&
+      error.name === 'ExecutionDoesNotExist'
+    ) {
+      return undefined;
+    }
+    throw error;
+  }
+};
+const startExecution = async (name) => {
+  try {
+    await sfn.send(
+      new StartExecutionCommand({
+        input: JSON.stringify({
+          databaseLifecycleCorrelationId,
+          databaseIdentifier: selectedDatabase,
+          sourceCommit,
+          stage,
+          slice: '${name}',
+          workflowRunId: runIdentity,
+          workflowRunAttempt: runAttempt,
+        }),
+        name,
+        stateMachineArn,
+      }),
+    );
+  } catch (error) {
+    if (
+      !error ||
+      typeof error !== 'object' ||
+      error.name !== 'ExecutionAlreadyExists'
+    ) {
+      throw error;
+    }
+  }
+};
+const terminal = new Set([
+  'ABORTED',
+  'FAILED',
+  'SUCCEEDED',
+  'TIMED_OUT',
+]);
+
+let executionName = baseExecutionName;
+let execution = await describeExecution(executionName);
+if (
+  execution &&
+  terminal.has(execution.status ?? 'UNKNOWN') &&
+  execution.status !== 'SUCCEEDED' &&
+  parsedRunAttempt > 1
+) {
+  const retrySuffix = '-retry-' + runAttempt;
+  executionName =
+    baseExecutionName.slice(0, 80 - retrySuffix.length) + retrySuffix;
+  execution = await describeExecution(executionName);
+}
+if (!execution) {
+  await startExecution(executionName);
+}
+
+const executionArn = executionArnFor(executionName);
+let status = execution?.status ?? 'RUNNING';
+process.stdout.write(
+  '[database-migration] execution=' + executionArn + ' status=' + status + '\\n',
+);
+const deadline = Date.now() + 95 * 60 * 1000;
+while (!terminal.has(status)) {
+  if (Date.now() >= deadline) {
+    throw new Error(
+      'Timed out waiting for database migration execution ' + executionArn,
+    );
+  }
+  await new Promise((resolve) => setTimeout(resolve, 5_000));
+  const execution = await sfn.send(
+    new DescribeExecutionCommand({ executionArn }),
+  );
+  status = execution.status ?? 'UNKNOWN';
+}
+if (status !== 'SUCCEEDED') {
+  throw new Error(
+    'Database migration execution ' +
+      executionArn +
+      ' ended with status ' +
+      status +
+      '. Inspect its Step Functions and CloudWatch records.',
+  );
+}
+process.stdout.write(
+  '[database-migration] execution=' + executionArn + ' status=SUCCEEDED\\n',
+);
+`,
+        'sst-env.d.ts': `// Bootstrap placeholder. SST overwrites this file after install, dev, or deploy.
+export {};
+`,
+        'sst.config.ts': `export default $config({
+  app(input: { stage?: string } | undefined) {
+    const stage = input?.stage ?? 'development';
+    const production = input?.stage === 'production';
+    return {
+      name: '${name}',
+      removal: production ? 'retain' : 'remove',
+      protect: production,
+      home: 'aws',
+      providers: {
+        aws: {
+          defaultTags: {
+            tags: {
+              'ebk:cost-allocation': 'unallocated',
+              'ebk:cost-scope': '${workspace}/${name}/' + stage,
+              'ebk:framework-version': '${frameworkVersion}',
+              'ebk:managed-by': 'empire-builder-kit',
+              'ebk:owner': '${name}-product',
+              'ebk:production-profile':
+                process.env.EBK_PRODUCTION_PROFILE ?? 'standard',
+              'ebk:repository':
+                process.env.GITHUB_REPOSITORY ?? '${workspace}',
+              'ebk:slice': '${name}',
+              'ebk:stage': stage,
+              'ebk:workspace': '${workspace}',
+            },
+          },
+          region: process.env.AWS_REGION ?? 'us-east-1',
+        },
+      },
+    };
+  },
+  async run() {
+    const personalStagePattern = /^personal-[a-z0-9](?:[a-z0-9-]{0,34}[a-z0-9])?$/;
+    if ($dev && !personalStagePattern.test($app.stage)) {
+      throw new Error(
+        'SST dev requires the framework-derived personal stage. Use ebk dev.',
+      );
+    }
+    if (!$dev && personalStagePattern.test($app.stage)) {
+      throw new Error(
+        'A personal stage may run only through the framework development adapter.',
+      );
+    }
+    const workloadRoles = $dev
+      ? undefined
+      : await (async () => {
+          const { preflightStandardSliceWorkloadRoles } = await import(
+            './infra/workload-roles/preflight.js'
+          );
+          return preflightStandardSliceWorkloadRoles($app.stage);
+        })();
+    const { app } = await import('./infra/index.js');
+    return app(workloadRoles);
+  },
+});
+`,
+        'tsconfig.json': (0, built_in_plan_shared_js_1.json)({
+            extends: '../../tsconfig.base.json',
+            compilerOptions: {
+                allowJs: true,
+                esModuleInterop: true,
+                jsx: 'react-jsx',
+                lib: ['dom', 'dom.iterable', 'es2022'],
+                module: 'esnext',
+                moduleResolution: 'bundler',
+                plugins: [{ name: 'next' }],
+                resolveJsonModule: true,
+                types: ['node'],
+            },
+            include: [
+                'async/**/*.ts',
+                'authorization/**/*.ts',
+                'configuration/**/*.ts',
+                'contracts/**/*.ts',
+                'database/**/*.ts',
+                'data/**/*.ts',
+                'data/**/*.cts',
+                'api/**/*.ts',
+                'infra/**/*.ts',
+                'jobs/**/*.ts',
+                'reliability/**/*.ts',
+                'secrets/**/*.ts',
+                'services/**/*.ts',
+                'web/**/*.ts',
+                'web/**/*.tsx',
+                'vitest.config.ts',
+                'sst.config.ts',
+                'sst-env.d.ts',
+                'ebk-globals.d.ts',
+            ],
+            exclude: ['.sst', 'dist', 'node_modules'],
+        }),
+    };
+}
+//# sourceMappingURL=built-in-plan-operations-files.js.map

package/src/generators/slice/built-in-plan-operations-files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-in-plan-operations-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-operations-files.ts"],"names":[],"mappings":"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"}

package/src/generators/slice/built-in-plan-performance-files.d.ts

@@ -0,0 +1,3 @@
+export declare const PRODUCT_PERFORMANCE_SEEDED_PATHS: readonly ["docs/runbooks/performance-capacity-cost.md", "performance/aggregate-count-provider.ts", "performance/cost-allocation.json", "performance/cost-collection.json", "performance/load-scenarios.json", "performance/policy.json"];
+/** @internal */
+export declare function renderProductPerformanceFiles(name: string): Readonly<Record<string, string>>;