@3fn/core 14.0.0 → 15.0.0

package/dist/build/platforms/iOSMotionTokenFormatter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * iOS Motion Token Formatter
+ *
+ * Generates the Swift motion-token section (duration/easing/scale constants and
+ * semantic motion structs) consumed by TokenFileGenerator.generateMotionSection().
+ *
+ * NOT the shipping iOS constant generator. Primitive/semantic/component token
+ * constants ship via TokenFileGenerator + src/providers/iOSFormatGenerator.ts.
+ *
+ * History: this class previously implemented PlatformBuilder with a full
+ * Swift-package build() path (Package.swift, SwiftUI components, validators).
+ * That path was never wired into any shipping pipeline and was retired
+ * 2026-08-26 alongside AndroidBuilder's (see
+ * .kiro/issues/2026-08-26-androidbuilder-camelcase-dead-path.md).
+ */
+export declare class iOSMotionTokenFormatter {
+    /**
+     * Generate duration token Swift constants
+     *
+     * Generates Swift constants for animation duration tokens.
+     * Format: let duration150: TimeInterval = 0.15
+     *
+     * Converts milliseconds to seconds for iOS TimeInterval.
+     *
+     * Requirements: 1.6, 6.2, 6.5
+     *
+     * @param durationTokens - Duration primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateDurationTokens(durationTokens: Record<string, any>): string;
+    /**
+     * Generate easing token Swift constants
+     *
+     * Generates Swift constants for animation easing tokens using Animation.timingCurve().
+     * Format: let easingStandard = Animation.timingCurve(0.4, 0.0, 0.2, 1.0)
+     *
+     * Converts cubic-bezier CSS format to Swift Animation.timingCurve format.
+     *
+     * Requirements: 2.6, 6.2, 6.6
+     *
+     * @param easingTokens - Easing primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateEasingTokens(easingTokens: Record<string, any>): string;
+    /**
+     * Generate scale token Swift constants
+     *
+     * Generates Swift constants for transform scale tokens.
+     * Format: let scale088: CGFloat = 0.88
+     *
+     * Scale tokens are unitless factors that should be applied to base values.
+     * When applying scale tokens to base values during token generation,
+     * use unitConverter.applyScaleWithRounding() to ensure whole pixel values.
+     *
+     * Example:
+     *   const baseSize = 16;
+     *   const scaledSize = unitConverter.applyScaleWithRounding(baseSize, 0.88);
+     *   // Result: 14 (16 × 0.88 = 14.08 → rounds to 14)
+     *
+     * In Swift, components should apply rounding when using scale tokens:
+     *   let scaledSize = round(baseSize * Tokens.Scale.scale088)
+     *
+     * Requirements: 3.1, 4.2, 4.3, 6.2
+     *
+     * @param scaleTokens - Scale primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateScaleTokens(scaleTokens: Record<string, any>): string;
+    /**
+     * Generate semantic motion token Swift constants
+     *
+     * Generates Swift structs for semantic motion tokens that compose
+     * primitive duration, easing, and scale tokens.
+     *
+     * Format:
+     *   struct MotionFloatLabel {
+     *     let duration = Duration.duration250
+     *     let easing = Easing.easingStandard
+     *   }
+     *
+     * Requirements: 5.1, 5.2, 6.5
+     *
+     * @param motionTokens - Semantic motion tokens from token system
+     * @returns Swift struct declarations
+     */
+    generateSemanticMotionTokens(motionTokens: Record<string, any>): string;
+    /**
+     * Convert token name to Swift type name (PascalCase)
+     *
+     * Converts names like "motion.floatLabel" to "MotionFloatLabel"
+     * Used for struct and enum names.
+     */
+    private toSwiftTypeName;
+    /**
+     * Convert token name to Swift constant name
+     */
+    private toSwiftConstantName;
+}
+//# sourceMappingURL=iOSMotionTokenFormatter.d.ts.map

package/dist/build/platforms/iOSMotionTokenFormatter.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iOSMotionTokenFormatter = void 0;
+/**
+ * iOS Motion Token Formatter
+ *
+ * Generates the Swift motion-token section (duration/easing/scale constants and
+ * semantic motion structs) consumed by TokenFileGenerator.generateMotionSection().
+ *
+ * NOT the shipping iOS constant generator. Primitive/semantic/component token
+ * constants ship via TokenFileGenerator + src/providers/iOSFormatGenerator.ts.
+ *
+ * History: this class previously implemented PlatformBuilder with a full
+ * Swift-package build() path (Package.swift, SwiftUI components, validators).
+ * That path was never wired into any shipping pipeline and was retired
+ * 2026-08-26 alongside AndroidBuilder's (see
+ * .kiro/issues/2026-08-26-androidbuilder-camelcase-dead-path.md).
+ */
+class iOSMotionTokenFormatter {
+    /**
+     * Generate duration token Swift constants
+     *
+     * Generates Swift constants for animation duration tokens.
+     * Format: let duration150: TimeInterval = 0.15
+     *
+     * Converts milliseconds to seconds for iOS TimeInterval.
+     *
+     * Requirements: 1.6, 6.2, 6.5
+     *
+     * @param durationTokens - Duration primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateDurationTokens(durationTokens) {
+        const lines = [];
+        lines.push('    // MARK: - Duration Tokens');
+        lines.push('    ');
+        lines.push('    /// Animation duration values in seconds (TimeInterval)');
+        lines.push('    public enum Duration {');
+        for (const [name, token] of Object.entries(durationTokens)) {
+            const swiftName = this.toSwiftConstantName(name);
+            const valueInSeconds = token.platforms.ios.value; // Already converted to seconds in token definition
+            const comment = `        /// ${name}: ${valueInSeconds}s (${token.baseValue}ms)`;
+            lines.push(comment);
+            lines.push(`        public static let ${swiftName}: TimeInterval = ${valueInSeconds}`);
+        }
+        lines.push('    }');
+        lines.push('    ');
+        return lines.join('\n');
+    }
+    /**
+     * Generate easing token Swift constants
+     *
+     * Generates Swift constants for animation easing tokens using Animation.timingCurve().
+     * Format: let easingStandard = Animation.timingCurve(0.4, 0.0, 0.2, 1.0)
+     *
+     * Converts cubic-bezier CSS format to Swift Animation.timingCurve format.
+     *
+     * Requirements: 2.6, 6.2, 6.6
+     *
+     * @param easingTokens - Easing primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateEasingTokens(easingTokens) {
+        const lines = [];
+        const hasLinear = Object.values(easingTokens).some((t) => t.easingType === 'linear');
+        lines.push('    // MARK: - Easing Tokens');
+        lines.push('    ');
+        if (hasLinear) {
+            lines.push('    /// Piecewise linear easing via CustomAnimation (iOS 17+)');
+            lines.push('    struct PiecewiseLinearEasing: CustomAnimation {');
+            lines.push('        let stops: [(time: Double, progress: Double)]');
+            lines.push('        let duration: Double');
+            lines.push('        func animate<V>(value: V, time: TimeInterval, context: inout AnimationContext<V>) -> V? where V: VectorArithmetic {');
+            lines.push('            let t = min(time / duration, 1.0)');
+            lines.push('            guard t < 1.0 else { return nil }');
+            lines.push('            var lo = 0, hi = stops.count - 1');
+            lines.push('            while lo < hi - 1 { let mid = (lo + hi) / 2; if stops[mid].time <= t { lo = mid } else { hi = mid } }');
+            lines.push('            let seg = stops[lo], next = stops[hi]');
+            lines.push('            let frac = next.time > seg.time ? (t - seg.time) / (next.time - seg.time) : 1.0');
+            lines.push('            let progress = seg.progress + (next.progress - seg.progress) * frac');
+            lines.push('            return value.scaled(by: progress)');
+            lines.push('        }');
+            lines.push('    }');
+            lines.push('    ');
+        }
+        lines.push('    /// Animation easing curves');
+        lines.push('    public enum Easing {');
+        for (const [name, token] of Object.entries(easingTokens)) {
+            const swiftName = this.toSwiftConstantName(name);
+            if (token.easingType === 'linear' && token.stops) {
+                const stops = token.stops
+                    .map(([time, progress]) => `(${time}, ${progress})`).join(', ');
+                const dur = (token.easingDuration / 1000).toFixed(2);
+                lines.push(`        /// ${name}: piecewise linear (${token.stops.length} stops, ${token.easingDuration}ms)`);
+                lines.push(`        public static let ${swiftName} = Animation(PiecewiseLinearEasing(stops: [${stops}], duration: ${dur}))`);
+            }
+            else {
+                const cubicBezier = token.platforms.ios.value;
+                const match = cubicBezier.match(/cubic-bezier\(([\d.]+),\s*([\d.]+),\s*([\d.]+),\s*([\d.]+)\)/);
+                if (match) {
+                    const [, p1, p2, p3, p4] = match;
+                    lines.push(`        /// ${name}: Animation.timingCurve(${p1}, ${p2}, ${p3}, ${p4})`);
+                    lines.push(`        public static let ${swiftName} = Animation.timingCurve(${p1}, ${p2}, ${p3}, ${p4})`);
+                }
+            }
+        }
+        lines.push('    }');
+        lines.push('    ');
+        return lines.join('\n');
+    }
+    /**
+     * Generate scale token Swift constants
+     *
+     * Generates Swift constants for transform scale tokens.
+     * Format: let scale088: CGFloat = 0.88
+     *
+     * Scale tokens are unitless factors that should be applied to base values.
+     * When applying scale tokens to base values during token generation,
+     * use unitConverter.applyScaleWithRounding() to ensure whole pixel values.
+     *
+     * Example:
+     *   const baseSize = 16;
+     *   const scaledSize = unitConverter.applyScaleWithRounding(baseSize, 0.88);
+     *   // Result: 14 (16 × 0.88 = 14.08 → rounds to 14)
+     *
+     * In Swift, components should apply rounding when using scale tokens:
+     *   let scaledSize = round(baseSize * Tokens.Scale.scale088)
+     *
+     * Requirements: 3.1, 4.2, 4.3, 6.2
+     *
+     * @param scaleTokens - Scale primitive tokens from token system
+     * @returns Swift constant declarations
+     */
+    generateScaleTokens(scaleTokens) {
+        const lines = [];
+        lines.push('    // MARK: - Scale Tokens');
+        lines.push('    ');
+        lines.push('    /// Transform scale factors (unitless)');
+        lines.push('    /// When applying to base values, use round() for whole pixels');
+        lines.push('    public enum Scale {');
+        for (const [name, token] of Object.entries(scaleTokens)) {
+            const swiftName = this.toSwiftConstantName(name);
+            const value = token.platforms.ios.value;
+            const comment = `        /// ${name}: ${value}`;
+            lines.push(comment);
+            lines.push(`        public static let ${swiftName}: CGFloat = ${value}`);
+        }
+        lines.push('    }');
+        lines.push('    ');
+        return lines.join('\n');
+    }
+    /**
+     * Generate semantic motion token Swift constants
+     *
+     * Generates Swift structs for semantic motion tokens that compose
+     * primitive duration, easing, and scale tokens.
+     *
+     * Format:
+     *   struct MotionFloatLabel {
+     *     let duration = Duration.duration250
+     *     let easing = Easing.easingStandard
+     *   }
+     *
+     * Requirements: 5.1, 5.2, 6.5
+     *
+     * @param motionTokens - Semantic motion tokens from token system
+     * @returns Swift struct declarations
+     */
+    generateSemanticMotionTokens(motionTokens) {
+        const lines = [];
+        lines.push('    // MARK: - Semantic Motion Tokens');
+        lines.push('    ');
+        lines.push('    /// Composed motion styles for specific animation contexts');
+        for (const [name, token] of Object.entries(motionTokens)) {
+            const structName = this.toSwiftTypeName(name);
+            const { duration, easing, scale } = token.primitiveReferences;
+            lines.push('    ');
+            lines.push(`    /// ${token.description}`);
+            lines.push(`    public struct ${structName} {`);
+            // Generate duration reference
+            const durationSwiftName = this.toSwiftConstantName(duration);
+            lines.push(`        public static let duration = Duration.${durationSwiftName}`);
+            // Generate easing reference
+            const easingSwiftName = this.toSwiftConstantName(easing);
+            lines.push(`        public static let easing = Easing.${easingSwiftName}`);
+            // Generate scale reference if present
+            if (scale) {
+                const scaleSwiftName = this.toSwiftConstantName(scale);
+                lines.push(`        public static let scale = Scale.${scaleSwiftName}`);
+            }
+            lines.push('    }');
+        }
+        lines.push('    ');
+        return lines.join('\n');
+    }
+    /**
+     * Convert token name to Swift type name (PascalCase)
+     *
+     * Converts names like "motion.floatLabel" to "MotionFloatLabel"
+     * Used for struct and enum names.
+     */
+    toSwiftTypeName(name) {
+        return name
+            .split('.')
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+    }
+    /**
+     * Convert token name to Swift constant name
+     */
+    toSwiftConstantName(name) {
+        // Convert names like "space100" to "space100"
+        // Convert names like "color.blue.500" to "colorBlue500"
+        return name
+            .replace(/\./g, '_')
+            .replace(/-/g, '_')
+            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+}
+exports.iOSMotionTokenFormatter = iOSMotionTokenFormatter;
+//# sourceMappingURL=iOSMotionTokenFormatter.js.map

package/dist/build/tokens/defineComponentTokens.d.ts

@@ -60,6 +60,16 @@ export interface PrimitiveTokenReference {
     name: string;
     /** Unitless base value from the primitive token */
     baseValue: number;
+    /**
+     * Primitive token family (the `category` field of a `PrimitiveToken`, e.g. 'spacing',
+     * 'sizing', 'radius'). OPTIONAL for backward compatibility: minimal `{ name, baseValue }`
+     * reference literals remain valid.
+     *
+     * When present, it is cross-checked against the call's declared `family` by the
+     * family-mismatch guard in {@link defineComponentTokens}. Real primitives from
+     * src/tokens/** always carry it, so the guard is active for all production authoring.
+     */
+    category?: string;
 }
 /**
  * Token definition with primitive reference

package/dist/build/tokens/defineComponentTokens.js

@@ -125,6 +125,32 @@ function defineComponentTokens(config) {
         if (isTokenWithReference(definition)) {
             // Token with primitive reference
             const primitiveToken = definition.reference;
+            // FAMILY-MISMATCH GUARD.
+            // The call's `family` is stamped onto every token it registers, and the generator
+            // derives platform output from it — notably the primitive class name used for
+            // reference-path tokens (getFamilyClassName) and the Android `.dp` suffix. A call
+            // that declares one family but references another family's primitive therefore emits
+            // a member that does not exist on the target platform. That is exactly the Button-Icon
+            // defect: a `family: 'spacing'` call referencing `sizingTokens.size600` generated
+            // `SpacingTokens.size600`, a non-existent member (PR #126).
+            //
+            // Only enforced when the reference carries a `category` — minimal `{ name, baseValue }`
+            // literals (used widely in tests) are intentionally exempt rather than rejected.
+            //
+            // Escape hatch: a token that legitimately needs another family's VALUE should use the
+            // value path (`value:`), which asserts no cross-family token-chain claim.
+            if (typeof primitiveToken.category === 'string' &&
+                primitiveToken.category !== family) {
+                throw new Error(`Token family mismatch in defineComponentTokens() for component '${component}': ` +
+                    `token '${key}' is declared in a '${family}' family call but references primitive ` +
+                    `'${primitiveToken.name}' from the '${primitiveToken.category}' family. ` +
+                    `Every token in a call is stamped with that call's family, which drives platform ` +
+                    `output (e.g. the generated '${family.charAt(0).toUpperCase() + family.slice(1)}Tokens' ` +
+                    `class reference), so this would emit a non-existent platform member. ` +
+                    `Fix: move '${key}' into a separate defineComponentTokens() call with ` +
+                    `family: '${primitiveToken.category}', or use the value path if no token-chain ` +
+                    `relationship is intended.`);
+            }
             const value = primitiveToken.baseValue;
             values[key] = value;
             registeredTokens.push({

package/dist/build/validation/index.d.ts

@@ -11,10 +11,6 @@ export { PropertyTypeValidator } from './PropertyTypeValidator';
 export type { PropertyComparison, PropertyValidationResult } from './PropertyTypeValidator';
 export { ValidationReporter } from './ValidationReporter';
 export type { DetailedValidationReport, ValidationSummary, PlatformValidationDetail, DetailedError, DetailedWarning, PlatformDifference, ActionableSuggestion, } from './ValidationReporter';
-export { iOSBuildValidator } from './iOSBuildValidator';
-export type { iOSValidationResult } from './iOSBuildValidator';
-export { AndroidBuildValidator } from './AndroidBuildValidator';
-export { WebBuildValidator } from './WebBuildValidator';
 export { MathematicalConsistencyValidator } from './MathematicalConsistencyValidator';
 export type { BuildMathematicalConsistencyResult, AccessibilityValidationResult, ContrastRatioIssue, TouchTargetIssue, } from './MathematicalConsistencyValidator';
 export { TokenComparator } from './TokenComparator';

package/dist/build/validation/index.js

@@ -6,7 +6,7 @@
  * API contract validation and platform-specific build validators.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InterfaceContractValidator = exports.TokenComparator = exports.MathematicalConsistencyValidator = exports.WebBuildValidator = exports.AndroidBuildValidator = exports.iOSBuildValidator = exports.ValidationReporter = exports.PropertyTypeValidator = exports.MethodSignatureValidator = exports.InterfaceValidator = void 0;
+exports.InterfaceContractValidator = exports.TokenComparator = exports.MathematicalConsistencyValidator = exports.ValidationReporter = exports.PropertyTypeValidator = exports.MethodSignatureValidator = exports.InterfaceValidator = void 0;
 var InterfaceValidator_1 = require("./InterfaceValidator");
 Object.defineProperty(exports, "InterfaceValidator", { enumerable: true, get: function () { return InterfaceValidator_1.InterfaceValidator; } });
 var MethodSignatureValidator_1 = require("./MethodSignatureValidator");
@@ -15,13 +15,6 @@ var PropertyTypeValidator_1 = require("./PropertyTypeValidator");
 Object.defineProperty(exports, "PropertyTypeValidator", { enumerable: true, get: function () { return PropertyTypeValidator_1.PropertyTypeValidator; } });
 var ValidationReporter_1 = require("./ValidationReporter");
 Object.defineProperty(exports, "ValidationReporter", { enumerable: true, get: function () { return ValidationReporter_1.ValidationReporter; } });
-// Platform-specific build validators
-var iOSBuildValidator_1 = require("./iOSBuildValidator");
-Object.defineProperty(exports, "iOSBuildValidator", { enumerable: true, get: function () { return iOSBuildValidator_1.iOSBuildValidator; } });
-var AndroidBuildValidator_1 = require("./AndroidBuildValidator");
-Object.defineProperty(exports, "AndroidBuildValidator", { enumerable: true, get: function () { return AndroidBuildValidator_1.AndroidBuildValidator; } });
-var WebBuildValidator_1 = require("./WebBuildValidator");
-Object.defineProperty(exports, "WebBuildValidator", { enumerable: true, get: function () { return WebBuildValidator_1.WebBuildValidator; } });
 // Cross-platform mathematical consistency validator
 var MathematicalConsistencyValidator_1 = require("./MathematicalConsistencyValidator");
 Object.defineProperty(exports, "MathematicalConsistencyValidator", { enumerable: true, get: function () { return MathematicalConsistencyValidator_1.MathematicalConsistencyValidator; } });

package/dist/cli/attach.d.ts

@@ -0,0 +1,153 @@
+/**
+ * `npx designerpunk attach` — attach a harness (agents + MCP config + approvals)
+ * for one target (Spec 123 Task 16.2; design.md § "C20. The consumer emission
+ * lane — shipped inputs only"; C1's "(new) agent layer" row; C7's manifest).
+ *
+ * Unlike `init` (the once-ever birth event), `attach` is SAFE TO RE-RUN: it
+ * regenerates a target's agent layer and MCP wiring, and running it again on an
+ * already-attached target changes nothing it would not have written identically
+ * (19.8's collision rule governs what is "ours" to regenerate versus a path the
+ * consumer occupies with her own content).
+ *
+ * **Modes** (C20):
+ * - **born repo, no `--reference`** → full emission: the agent layer (charters,
+ *   identity member files, skill trees, the CLAUDE.md always-layer region) for
+ *   the selected target, plus that target's MCP config + approvals (all three
+ *   servers — the same shape `init` emits).
+ * - **`--reference`** (works regardless of birth state) → the CONSUME posture's
+ *   mechanical wiring: MCP config + approvals for ONLY the docs and application
+ *   servers (never `designerpunk-product`, and no agents, no birth). Writes a
+ *   `posture: 'consume'` manifest, which `findDesignSystemRoot` (C2) IGNORES as
+ *   a birth signal — a second `--reference` run re-runs clean, and a later
+ *   `init` still births (design.md C6: "attach --reference stays CONSUME").
+ * - **unborn, no `--reference`** → refuse, naming both paths (the catalog row).
+ * - **partial** → the partial-case message (shared with `init`/`generate`).
+ *
+ * **`attach` never appears without its object** (C20, DD4) — see
+ * `./shared/vocabulary.ts`'s `attachUsage()`, used at this file's dispatch
+ * point (`designerpunk.ts`'s help text) and already present verbatim in
+ * `initBornRepoMessage`'s catalog string.
+ *
+ * APPLICATION-TIME ADAPTATION (recorded in the Task 16.2 completion doc):
+ * design.md's C20 "Modes" list names only `born` / `--reference` / `unborn` /
+ * `partial`. `package-mode` (C2's own posture — a config without `tokenSource`)
+ * is unaddressed there. This module treats `package-mode` the same as `born`
+ * for `attach`'s purposes: attach is about the agent harness, not the token
+ * tier, and a `package-mode` repo already has a real `designerpunk.config.ts`,
+ * which is what "a design system here" means for this command. CONFIRMED by
+ * the PRIMARY at Task 16.5 (DD23 made `package-mode` a posture, not a partial;
+ * C20's Modes list predates that split).
+ *
+ * @see .kiro/specs/123-consumer-distribution/design.md § "C20. The consumer emission lane"
+ * @see .kiro/specs/123-consumer-distribution/design.md § "C7. `sync` … Manifest"
+ */
+import type { McpConfigManifestRecorder, McpConfigTemplate } from './shared/mcpConfig/kiro';
+import type { DesignerPunkManifest, ManifestOrigin } from './sync/Manifest';
+interface AttachOptions {
+    target?: string;
+    reference?: boolean;
+}
+declare function parseAttachArgs(argv: string[]): AttachOptions;
+interface ConsumerEmittedFileLike {
+    path: string;
+    content: string;
+    grain: 'file' | 'region';
+}
+interface EmitConsumerResultLike {
+    target: string;
+    mode: string;
+    files: ConsumerEmittedFileLike[];
+    keys: string[];
+    warnings: string[];
+}
+interface ConsumerProfileLike {
+    targets: readonly string[];
+    defaultTarget: string;
+}
+interface ConsumerEntryModule {
+    loadPackagedConsumerProfile(packageRoot: string): ConsumerProfileLike;
+    emitConsumer(opts: {
+        packageRoot: string;
+        consumerRoot: string;
+        target: string;
+        mode: 'birth' | 'attach' | 'reference' | 'sync';
+    }): Promise<EmitConsumerResultLike>;
+}
+/** Resolve the target to act on: the requested `--target`, else the profile's declared default (DD9). Throws, naming the declared set, on an undeclared target. `verb` names the calling command in the message (`attach` by default; `init` passes its own). */
+declare function resolveTarget(requested: string | undefined, profile: ConsumerProfileLike, verb?: string): string;
+/**
+ * Load the shipped consumer-entry bundle and resolve the target against the PACKAGED consumer
+ * profile (`loadConsumerProfile`'s packaged form — C12's single declared list; never a literal
+ * target list). `init` calls this up front so an undeclared `--target` or an unbuilt package
+ * fails before it writes anything; `emitAgentLayer` calls it again (the require is cached).
+ */
+declare function resolveAgentTarget(pkgRoot: string, requested: string | undefined, verb?: string): {
+    entry: ConsumerEntryModule;
+    target: string;
+    profile: ConsumerProfileLike;
+};
+/** `McpConfigManifestRecorder` over a `DesignerPunkManifest`'s `entries` (mirrors `init.ts`'s `ManifestBuilder`, scoped to recording — `attach` updates an EXISTING manifest rather than building a fresh one). */
+declare class AttachManifestRecorder implements McpConfigManifestRecorder {
+    private readonly manifest;
+    constructor(manifest: Pick<DesignerPunkManifest, 'entries'>);
+    recordFile(relPath: string, absPath: string, origin: ManifestOrigin): void;
+    recordKey(relPath: string, key: string, value: unknown): void;
+}
+type ApplyOutcome = 'written' | 'unchanged' | 'collision';
+declare function applyEmittedFile(repoRoot: string, file: ConsumerEmittedFileLike, manifest: Pick<DesignerPunkManifest, 'entries'>, adoptIdentical?: boolean): ApplyOutcome;
+/** `--reference`'s servers (C20): the docs and application servers only — never `designerpunk-product`. `sync` reads it too (a consume-posture manifest's package-side keys). */
+export declare const REFERENCE_SERVERS: readonly string[];
+/** `--reference`'s scope (C20): the docs and application servers only — never `designerpunk-product`, and no agents. */
+declare function referenceOnlyTemplate(template: McpConfigTemplate): McpConfigTemplate;
+/** What `emitAgentLayer` did — the emitted file list `init` and `attach` both report (design.md C1: "It returns its emitted file list"). */
+export interface AgentLayerOutcome {
+    target: string;
+    /** Repo-relative paths the lane wrote or found already identical (each now has a manifest entry), in emission order. Empty when the agent files were skipped. */
+    files: string[];
+    written: number;
+    unchanged: number;
+    /** Paths the consumer already occupies with content DesignerPunk did not generate (Req 19.8) — reported, never overwritten, never recorded. */
+    collided: number;
+    warnings: string[];
+}
+/**
+ * THE agent-layer code path — `attach`'s full emission, and the row `init` calls for the selected
+ * target (design.md C1's "(new) agent layer" row: "`attach` code path for the selected target …
+ * returns its emitted file list"). One implementation, two callers: the agent layer (charters,
+ * identity member files, skill trees, the `CLAUDE.md` region) through `emitConsumer`, then that
+ * target's MCP config + approvals (all three servers), every file and key recorded into
+ * `manifest` (`origin: 'generated'` / `'emitted-key'`), and `target` added to
+ * `manifest.attachedTargets`.
+ *
+ * `skipAgentFiles` (`init --skip-agents`) omits the agent files AND the `attachedTargets` entry —
+ * the target is MCP-wired but not "attached" (the same line `attach --reference` draws), so
+ * generated-surface `sync` never expects agent files that were deliberately not emitted.
+ */
+export declare function emitAgentLayer(opts: {
+    pkgRoot: string;
+    repoRoot: string;
+    requestedTarget: string | undefined;
+    mode: 'birth' | 'attach';
+    manifest: Pick<DesignerPunkManifest, 'entries' | 'attachedTargets'>;
+    verb?: string;
+    skipAgentFiles?: boolean;
+    /** `init` sets this: a pre-existing path holding exactly the emitted bytes is adopted into the manifest rather than reported as a collision. */
+    adoptIdentical?: boolean;
+}): Promise<AgentLayerOutcome>;
+/** The repo-relative paths an agent-layer emission for `target` would create that do not exist in `repoRoot` today — `init --re-scaffold`'s "RE-ADDED" preview (Req 15A.3). Reads the package only; writes nothing. */
+export declare function previewAgentLayerMissing(pkgRoot: string, repoRoot: string, requestedTarget: string | undefined): Promise<string[]>;
+/**
+ * The refusal `attach` (no `--reference`) gives in `repoRoot`, or `null` when it would run (born or
+ * package-mode). One rule for `attach` itself and for `sync --migrate-legacy`'s attach step (Task 16.5),
+ * so `sync` never offers an attach that `attach` would refuse.
+ */
+export declare function attachRefusal(repoRoot: string): {
+    message: string;
+    root: string;
+} | {
+    message: null;
+    root: string;
+};
+export declare function runAttach(argv: string[]): Promise<void>;
+export { parseAttachArgs, resolveTarget, resolveAgentTarget, applyEmittedFile, AttachManifestRecorder, referenceOnlyTemplate };
+//# sourceMappingURL=attach.d.ts.map