@fjall/generator 0.94.1 → 0.96.0

package/dist/src/codemod/llmFallback/telemetryEvents.d.ts

@@ -0,0 +1,141 @@
+import type { GateId } from "../validationGate/types.js";
+import type { FallbackOp, FallbackTelemetry, TriggerReason } from "./types.js";
+import type { EgressRiskReason } from "./egressGate.types.js";
+import type { LlmFallbackTier } from "../types.js";
+export declare const FALLBACK_EVENTS: {
+    readonly FIRED: "codemod.llm_fallback.fired";
+    readonly SUCCEEDED: "codemod.llm_fallback.succeeded";
+    readonly REJECTED: "codemod.llm_fallback.rejected";
+    readonly TIMEOUT: "codemod.llm_fallback.timeout";
+    readonly EGRESS_BLOCKED: "codemod.llm_fallback.egress_blocked";
+};
+export declare const GATE_EVENTS: {
+    readonly PASSED: "codemod.gate.passed";
+    readonly FAILED: "codemod.gate.failed";
+};
+export type TelemetrySource = "cli" | "webapp_service" | "webapp_api" | "webapp_ui" | "mcp";
+export interface FallbackFiredEvent {
+    event: typeof FALLBACK_EVENTS.FIRED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        trigger: TriggerReason;
+        organisationId: string;
+    };
+}
+export interface FallbackSucceededEvent {
+    event: typeof FALLBACK_EVENTS.SUCCEEDED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        durationMs: number;
+        estimatedCostUsd: number;
+        organisationId: string;
+    };
+}
+export interface FallbackRejectedEvent {
+    event: typeof FALLBACK_EVENTS.REJECTED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        failedGate: GateId;
+        durationMs: number;
+        organisationId: string;
+    };
+}
+export interface FallbackTimeoutEvent {
+    event: typeof FALLBACK_EVENTS.TIMEOUT;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        elapsedMs: number;
+        organisationId: string;
+    };
+}
+export interface FallbackEgressBlockedEvent {
+    event: typeof FALLBACK_EVENTS.EGRESS_BLOCKED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        reason: EgressRiskReason;
+        count: number;
+        organisationId: string;
+    };
+}
+export interface GatePassedEvent {
+    event: typeof GATE_EVENTS.PASSED;
+    properties: {
+        gate: GateId;
+        operation: FallbackOp | "validate";
+        durationMs: number;
+        source: TelemetrySource;
+        organisationId: string;
+    };
+}
+export interface GateFailedEvent {
+    event: typeof GATE_EVENTS.FAILED;
+    properties: {
+        gate: GateId;
+        operation: FallbackOp | "validate";
+        durationMs: number;
+        source: TelemetrySource;
+        organisationId: string;
+    };
+}
+export type FallbackTelemetryEvent = FallbackFiredEvent | FallbackSucceededEvent | FallbackRejectedEvent | FallbackTimeoutEvent | FallbackEgressBlockedEvent | GatePassedEvent | GateFailedEvent;
+export declare function estimateCostUsd(telemetry: FallbackTelemetry): number;
+export declare function buildFiredEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    trigger: TriggerReason;
+    organisationId: string;
+}): FallbackFiredEvent;
+export declare function buildSucceededEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    telemetry: FallbackTelemetry;
+    organisationId: string;
+}): FallbackSucceededEvent;
+export declare function buildRejectedEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    durationMs: number;
+    organisationId: string;
+}): FallbackRejectedEvent;
+export declare function buildTimeoutEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+    organisationId: string;
+}): FallbackTimeoutEvent;
+export declare function buildEgressBlockedEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    reason: EgressRiskReason;
+    count: number;
+    organisationId: string;
+}): FallbackEgressBlockedEvent;
+export declare function buildGatePassedEvent(params: {
+    gate: GateId;
+    operation: FallbackOp | "validate";
+    durationMs: number;
+    source: TelemetrySource;
+    organisationId: string;
+}): GatePassedEvent;
+export declare function buildGateFailedEvent(params: {
+    gate: GateId;
+    operation: FallbackOp | "validate";
+    durationMs: number;
+    source: TelemetrySource;
+    organisationId: string;
+}): GateFailedEvent;

package/dist/src/codemod/llmFallback/telemetryEvents.js

@@ -0,0 +1 @@
+const t={FIRED:"codemod.llm_fallback.fired",SUCCEEDED:"codemod.llm_fallback.succeeded",REJECTED:"codemod.llm_fallback.rejected",TIMEOUT:"codemod.llm_fallback.timeout",EGRESS_BLOCKED:"codemod.llm_fallback.egress_blocked"},o={PASSED:"codemod.gate.passed",FAILED:"codemod.gate.failed"},E=3/1e6,d=15/1e6;function i(e){if(e.tier!=="claude")return 0;const n=e.inputTokens*E,r=e.outputTokens*d;return Math.round((n+r)*1e6)/1e6}function u(e){return{event:t.FIRED,properties:e}}function c(e){return{event:t.SUCCEEDED,properties:{source:e.source,operation:e.operation,tier:e.telemetry.tier,durationMs:e.telemetry.elapsedMs,estimatedCostUsd:i(e.telemetry),organisationId:e.organisationId}}}function l(e){return{event:t.REJECTED,properties:e}}function s(e){return{event:t.TIMEOUT,properties:e}}function p(e){return{event:t.EGRESS_BLOCKED,properties:e}}function _(e){return{event:o.PASSED,properties:e}}function a(e){return{event:o.FAILED,properties:e}}export{t as FALLBACK_EVENTS,o as GATE_EVENTS,p as buildEgressBlockedEvent,u as buildFiredEvent,a as buildGateFailedEvent,_ as buildGatePassedEvent,l as buildRejectedEvent,c as buildSucceededEvent,s as buildTimeoutEvent,i as estimateCostUsd};

package/dist/src/codemod/llmFallback/tierRunner.d.ts

@@ -0,0 +1,7 @@
+import type { LlmFallbackTier } from "../types.js";
+import { type FallbackOutput } from "./types.js";
+export interface TierTimeoutContext {
+    signal: AbortSignal;
+    started: number;
+}
+export declare function withTierTimeout(abortSignal: AbortSignal | undefined, tier: LlmFallbackTier, timeoutMs: number, fn: (ctx: TierTimeoutContext) => Promise<FallbackOutput>): Promise<FallbackOutput>;

package/dist/src/codemod/llmFallback/tierRunner.js

@@ -0,0 +1 @@
+import{linkAbortSignals as d}from"./signals.js";import{RUNTIME_GATE as f}from"./types.js";async function p(n,r,l,s){const a=new AbortController,{signal:c,cleanup:u}=d(n,a);let t,i=!1;const o=Date.now();try{return t=setTimeout(()=>{i=!0,a.abort()},l),await s({signal:c,started:o})}catch(e){return n?.aborted?{state:"cancelled"}:i?{state:"timeout",tier:r,elapsedMs:Date.now()-o}:{state:"rejected",tier:r,failedGate:f,diagnostics:e instanceof Error?e.message:String(e)}}finally{t!==void 0&&clearTimeout(t),u()}}export{p as withTierTimeout};

package/dist/src/codemod/llmFallback/types.d.ts

@@ -0,0 +1,104 @@
+import type { StatementType, ResourceName, LlmFallbackTier } from "../types.js";
+import type { GateId } from "../validationGate/types.js";
+import type { EgressRiskReason } from "./egressGate.types.js";
+export declare const PARSE_GATE: GateId;
+export declare const RUNTIME_GATE: GateId;
+export type FallbackOp = "add" | "modify" | "remove" | "resolve-drift-merge";
+export interface FallbackIntent {
+    op: FallbackOp;
+    type: StatementType;
+    name: ResourceName;
+    properties: Record<string, unknown>;
+}
+export interface FallbackInput {
+    content: string;
+    intent: FallbackIntent;
+    tier: LlmFallbackTier;
+    orgAllowsFallback: boolean;
+    abortSignal?: AbortSignal;
+}
+export type FallbackOutput = {
+    state: "applied";
+    content: string;
+    telemetry: FallbackTelemetry;
+} | {
+    state: "egress-blocked";
+    tier: LlmFallbackTier;
+    reason: EgressRiskReason;
+    count: number;
+} | {
+    state: "timeout";
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+} | {
+    state: "rejected";
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    diagnostics: string;
+} | {
+    state: "cancelled";
+} | {
+    state: "disabled";
+    reason: "env-flag" | "org-opt-out";
+};
+export interface FallbackTelemetry {
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    opsApplied: number;
+}
+export type TriggerReason = "template-literal-name" | "resource-not-found" | "control-flow-unclassifiable" | "drift-unmergeable";
+export interface StrReplaceOp {
+    old_str: string;
+    new_str: string;
+}
+export interface ApplyResult {
+    content: string;
+    appliedCount: number;
+    skippedCount: number;
+}
+export interface AnthropicClientProvider {
+    create(params: {
+        model: string;
+        max_tokens: number;
+        system: string;
+        messages: Array<{
+            role: "user";
+            content: string;
+        }>;
+        tools: readonly unknown[];
+        signal?: AbortSignal;
+    }): Promise<AnthropicResponse>;
+    resolveModelId(): string;
+}
+export interface AnthropicResponse {
+    content: readonly AnthropicContentBlock[];
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+}
+export type AnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    name: string;
+    input: Record<string, unknown>;
+};
+export interface MorphClientProvider {
+    apply(params: {
+        originalFile: string;
+        update: string;
+        signal?: AbortSignal;
+    }): Promise<MorphResponse>;
+    isAvailable(): boolean;
+}
+export interface MorphResponse {
+    content: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}

package/dist/src/codemod/llmFallback/types.js

@@ -0,0 +1 @@
+const t="parse",e="runtime";export{t as PARSE_GATE,e as RUNTIME_GATE};

package/dist/src/codemod/registry.d.ts

@@ -25,7 +25,7 @@ export interface StatementTypeEntry {
     factoryIdentifier: FactoryIdentifier;
     locator: StatementLocator;
     generator: StatementGenerator;
-    schemaFragment: z.ZodObject;
+    schemaFragment: z.ZodObject<z.ZodRawShape>;
 }
 declare const FACTORY_IDENTIFIERS: {
     readonly database: "DatabaseFactory";
@@ -35,6 +35,9 @@ declare const FACTORY_IDENTIFIERS: {
     readonly cdn: "CdnFactory";
     readonly network: "NetworkFactory";
     readonly pattern: "PatternFactory";
+    readonly "vpc-peer": "VpcPeerFactory";
+    readonly "vpc-peer-accepter": "VpcPeerAccepterFactory";
+    readonly "cross-plan-connection": "CrossPlanConnectionFactory";
 };
 export type FactoryIdentifier = (typeof FACTORY_IDENTIFIERS)[StatementType];
 export declare const STATEMENT_REGISTRY: Record<StatementType, StatementTypeEntry>;

package/dist/src/codemod/registry.js

@@ -1 +1 @@
-import{z as c}from"zod";import{CDNResourcePlanSchema as m,ComputeResourcePlanSchema as u,DatabaseResourcePlanSchema as p,NetworkResourcePlanSchema as g,NextJSPatternConfigSchema as d,PayloadPatternConfigSchema as h,S3ResourcePlanSchema as S,SQSResourcePlanSchema as l}from"../schemas/index.js";import{failure as y}from"../types/Result.js";const r={database:"DatabaseFactory",storage:"StorageFactory",compute:"ComputeFactory",messaging:"MessagingFactory",cdn:"CdnFactory",network:"NetworkFactory",pattern:"PatternFactory"};function n(t){const{name:e,...o}=t.shape;return c.object(o).partial().strict()}const f=n(p),F=n(S),b=(()=>{const{name:t,...e}=u.shape;return c.object(e).partial().strict()})(),E=n(l),w=n(m),P=n(g),R=(()=>{const{name:t,...e}=h.shape,{name:o,...i}=d.shape;return c.object({...e,...i}).partial().strict()})();function s(t,e){return y({kind:"SemanticQueryError",reason:`StatementTypeEntry.${t} for ${e} is not wired; existing types dispatch through the shared locator/generator.`})}function C(t){return{factoryIdentifier:t,findByShape:()=>s("locator.findByShape",t),validateContext:()=>s("locator.validateContext",t)}}function T(t){return{build:()=>{throw new Error(`StatementTypeEntry.generator.build for ${t} is not wired; existing types dispatch through the shared buildFactoryStatement.`)}}}function a(t,e){return{factoryIdentifier:t,locator:C(t),generator:T(t),schemaFragment:e}}const x={database:a(r.database,f),storage:a(r.storage,F),compute:a(r.compute,b),messaging:a(r.messaging,E),cdn:a(r.cdn,w),network:a(r.network,P),pattern:a(r.pattern,R)};function j(t){for(const[e,o]of Object.entries(x))if(o.factoryIdentifier===t)return e}export{x as STATEMENT_REGISTRY,j as findTypeByIdentifier};
+import{z as c}from"zod";import{CDNResourcePlanSchema as i,ComputeResourcePlanSchema as u,CrossPlanConnectionResourcePlanSchema as g,DatabaseResourcePlanSchema as l,NetworkResourcePlanSchema as h,NextJSPatternConfigSchema as d,PayloadPatternConfigSchema as y,S3ResourcePlanSchema as S,SQSResourcePlanSchema as F,VpcPeerAccepterResourcePlanSchema as P,VpcPeerResourcePlanSchema as f}from"../schemas/index.js";import{failure as C}from"../types/Result.js";const r={database:"DatabaseFactory",storage:"StorageFactory",compute:"ComputeFactory",messaging:"MessagingFactory",cdn:"CdnFactory",network:"NetworkFactory",pattern:"PatternFactory","vpc-peer":"VpcPeerFactory","vpc-peer-accepter":"VpcPeerAccepterFactory","cross-plan-connection":"CrossPlanConnectionFactory"};function a(e){const{name:t,...o}=e.shape;return c.object(o).partial().strict()}const b=a(l),R=a(S),v=(()=>{const{name:e,...t}=u.shape;return c.object(t).partial().strict()})(),E=a(F),w=a(i),k=a(h),T=(()=>{const{name:e,type:t,...o}=y.shape,{name:D,type:V,...m}=d.shape;return c.object({...o,...m}).partial().strict()})(),_=a(f),x=a(P),N=a(g);function s(e,t){return C({kind:"SemanticQueryError",reason:`StatementTypeEntry.${e} for ${t} is not wired; existing types dispatch through the shared locator/generator.`})}function j(e){return{factoryIdentifier:e,findByShape:()=>s("locator.findByShape",e),validateContext:()=>s("locator.validateContext",e)}}function A(e){return{build:()=>{const t=s("generator.build",e);throw new Error(t.success?"unreachable":t.error.reason)}}}function n(e,t){return{factoryIdentifier:e,locator:j(e),generator:A(e),schemaFragment:t}}const p={database:n(r.database,b),storage:n(r.storage,R),compute:n(r.compute,v),messaging:n(r.messaging,E),cdn:n(r.cdn,w),network:n(r.network,k),pattern:n(r.pattern,T),"vpc-peer":n(r["vpc-peer"],_),"vpc-peer-accepter":n(r["vpc-peer-accepter"],x),"cross-plan-connection":n(r["cross-plan-connection"],N)};function I(e){const t=Object.keys(p);for(const o of t)if(p[o].factoryIdentifier===e)return o}export{p as STATEMENT_REGISTRY,I as findTypeByIdentifier};

package/dist/src/codemod/semanticIndex/classifyControlFlow.d.ts

@@ -0,0 +1,2 @@
+export type ControlFlowClassification = "top-level" | "conditional" | "loop" | "function-body" | "unknown";
+export declare function classifyControlFlow(node: unknown, ancestors: readonly unknown[]): ControlFlowClassification;

package/dist/src/codemod/semanticIndex/classifyControlFlow.js

@@ -0,0 +1 @@
+const u=new Set(["IfStatement","ConditionalExpression","SwitchStatement","SwitchCase","CatchClause"]),c=new Set(["ForStatement","ForInStatement","ForOfStatement","WhileStatement","DoWhileStatement"]),a=new Set(["FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod"]);function p(n,t){if(t.length===0)return S(n);let e=n;for(let r=t.length-1;r>=0;r-=1){const o=t[r],i=f(o);if(i===void 0){e=o;continue}if(i==="TryStatement"){if(s(o,e))return"conditional";e=o;continue}if(u.has(i))return"conditional";if(c.has(i))return"loop";if(a.has(i))return"function-body";e=o}const l=f(t[0]);return l==="Program"||l==="File"?"top-level":"unknown"}function f(n){if(typeof n!="object"||n===null)return;const t=n.type;return typeof t=="string"?t:void 0}function s(n,t){if(typeof n!="object"||n===null)return!1;const e=n.finalizer;return e!==void 0&&e===t}function S(n){const t=f(n);return t==="Program"||t==="File"?"top-level":"unknown"}export{p as classifyControlFlow};

package/dist/src/codemod/semanticIndex/findReferences.js

@@ -1,2 +1,2 @@
-import{Node as d,SyntaxKind as m}from"ts-morph";import{failure as a,success as l}from"../../types/Result.js";import{DEFAULT_FILE_PATH as y}from"../_internal.js";import{getProject as S}from"./projectCache.js";const f=120;function T(r,n,e=y){let i;try{i=S().createSourceFile(e,r,{overwrite:!0})}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to create source file",cause:t})}let o;try{o=p(i,n.start)}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve declaration at the supplied offset",cause:t})}if(o===void 0)return l([]);let s;try{s=o.getSymbol()}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve symbol for declaration",cause:t})}if(s===void 0)return l([]);let c;try{c=o.findReferencesAsNodes()}catch(t){return a({kind:"SemanticQueryError",reason:"findReferencesAsNodes failed",cause:t})}const u=[];try{for(const t of c)g(t,s)&&(F(t,o)||u.push(b(t)))}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to map references to plain-data locations",cause:t})}return l(u)}function p(r,n){const e=r.getDescendantAtPos(n);return e===void 0?void 0:d.isVariableDeclaration(e)?e:e.getFirstAncestorByKind(m.VariableDeclaration)}function g(r,n){const e=r.getSymbol();return e===void 0?!1:e===n?!0:e.compilerSymbol===n.compilerSymbol}function F(r,n){const e=n.getNameNode();return r===e||r.getStart()===e.getStart()}function b(r){const n=r.getStart(),{line:e,column:i}=r.getSourceFile().getLineAndColumnAtPos(n),c=r.getSourceFile().getFullText().split(`
-`)[e-1]??"",u=c.length>f?c.slice(0,f):c;return{line:e,column:i,context:u}}export{T as findReferences};
+import{Node as m,SyntaxKind as y}from"ts-morph";import{failure as a,success as u}from"../../types/Result.js";import{DEFAULT_FILE_PATH as S}from"../_internal.js";import{getProject as p}from"./projectCache.js";const f=120;function D(r,n,e=S){let o;try{o=p().createSourceFile(e,r,{overwrite:!0})}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to create source file",cause:t})}let c;try{c=g(o,n.start)}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve declaration at the supplied offset",cause:t})}if(c===void 0)return u([]);let i;try{i=c.getSymbol()}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve symbol for declaration",cause:t})}if(i===void 0)return u([]);let s;try{s=c.findReferencesAsNodes()}catch(t){return a({kind:"SemanticQueryError",reason:"findReferencesAsNodes failed",cause:t})}const d=o.getFullText().split(`
+`),l=[];try{for(const t of s)F(t,i)&&(b(t,c)||l.push(A(t,d)))}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to map references to plain-data locations",cause:t})}return u(l)}function g(r,n){const e=r.getDescendantAtPos(n);return e===void 0?void 0:m.isVariableDeclaration(e)?e:e.getFirstAncestorByKind(y.VariableDeclaration)}function F(r,n){const e=r.getSymbol();return e===void 0?!1:e===n?!0:e.compilerSymbol===n.compilerSymbol}function b(r,n){const e=n.getNameNode();return r===e||r.getStart()===e.getStart()}function A(r,n){const e=r.getStart(),{line:o,column:c}=r.getSourceFile().getLineAndColumnAtPos(e),i=n[o-1]??"",s=i.length>f?i.slice(0,f):i;return{line:o,column:c,context:s}}export{D as findReferences};

package/dist/src/codemod/telemetry/__tests__/errorKinds.fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/codemod/telemetry/__tests__/errorKinds.fixture.js

@@ -0,0 +1 @@
+const e=!0;

package/dist/src/codemod/telemetry/errorKinds.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEMOD_ERROR_KINDS: readonly ["ParseError", "ResourceNotFoundError", "DuplicateResourceError", "ReferencesRemainError", "InvalidPropertyError", "TemplateLiteralNameError", "SemanticQueryError", "ValidationError", "IoError", "DriftConflictError", "DriftUnmergeableError", "PermissionError", "ControlFlowClassifierError", "LlmFallbackRejectedError", "LlmFallbackTimeoutError", "LlmFallbackUnsafeInputError"];
+export type CodemodErrorKind = (typeof CODEMOD_ERROR_KINDS)[number];

package/dist/src/codemod/telemetry/errorKinds.js

@@ -0,0 +1 @@
+const r=["ParseError","ResourceNotFoundError","DuplicateResourceError","ReferencesRemainError","InvalidPropertyError","TemplateLiteralNameError","SemanticQueryError","ValidationError","IoError","DriftConflictError","DriftUnmergeableError","PermissionError","ControlFlowClassifierError","LlmFallbackRejectedError","LlmFallbackTimeoutError","LlmFallbackUnsafeInputError"],e=!0;export{r as CODEMOD_ERROR_KINDS};

package/dist/src/codemod/types.d.ts

@@ -1,4 +1,11 @@
 import { z } from "zod";
+import type { GateId } from "./validationGate/types.js";
+import type { EgressRiskReason } from "./llmFallback/egressGate.types.js";
+export declare const DriftPolicySchema: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+    resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type DriftPolicy = z.infer<typeof DriftPolicySchema>;
 /**
  * The wider `StatementTypeSchema` in `schemas/baseSchemas.ts` also
  * carries non-factory kinds (import, app-init, tags, custom) that the
@@ -12,6 +19,9 @@ export declare const StatementTypeSchema: z.ZodEnum<{
     network: "network";
     messaging: "messaging";
     cdn: "cdn";
+    "vpc-peer": "vpc-peer";
+    "vpc-peer-accepter": "vpc-peer-accepter";
+    "cross-plan-connection": "cross-plan-connection";
 }>;
 export type StatementType = z.infer<typeof StatementTypeSchema>;
 export declare const ResourceNameSchema: z.ZodString;
@@ -25,10 +35,18 @@ export declare const AddOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     filePath: z.ZodOptional<z.ZodString>;
+    driftPolicy: z.ZodOptional<z.ZodObject<{
+        force: z.ZodOptional<z.ZodBoolean>;
+        resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type AddOptions = z.infer<typeof AddOptionsSchema>;
 export declare const RemoveOptionsSchema: z.ZodObject<{
@@ -40,10 +58,14 @@ export declare const RemoveOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     filePath: z.ZodOptional<z.ZodString>;
     force: z.ZodOptional<z.ZodBoolean>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type RemoveOptions = z.infer<typeof RemoveOptionsSchema>;
 export declare const ModifyOptionsSchema: z.ZodObject<{
@@ -55,10 +77,18 @@ export declare const ModifyOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     filePath: z.ZodOptional<z.ZodString>;
+    driftPolicy: z.ZodOptional<z.ZodObject<{
+        force: z.ZodOptional<z.ZodBoolean>;
+        resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ModifyOptions = z.infer<typeof ModifyOptionsSchema>;
 export declare const ReferenceLocationSchema: z.ZodObject<{
@@ -81,6 +111,9 @@ export declare const ResourceListingEntrySchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     filePath: z.ZodString;
@@ -99,6 +132,9 @@ export declare const ResourceListingSchema: z.ZodObject<{
             network: "network";
             messaging: "messaging";
             cdn: "cdn";
+            "vpc-peer": "vpc-peer";
+            "vpc-peer-accepter": "vpc-peer-accepter";
+            "cross-plan-connection": "cross-plan-connection";
         }>;
         name: z.ZodString;
         filePath: z.ZodString;
@@ -169,4 +205,72 @@ export interface SemanticQueryError {
     reason: string;
     cause?: unknown;
 }
-export type CodemodError = ParseError | TemplateLiteralNameError | DuplicateResourceError | ResourceNotFoundError | ReferencesRemainError | InvalidPropertyError | SemanticQueryError;
+export declare const PropertyDeltaSchema: z.ZodObject<{
+    property: z.ZodString;
+    base: z.ZodOptional<z.ZodUnknown>;
+    theirs: z.ZodUnknown;
+    ours: z.ZodUnknown;
+    verdict: z.ZodEnum<{
+        clean: "clean";
+        "no-op": "no-op";
+        compatible: "compatible";
+        conflict: "conflict";
+    }>;
+}, z.core.$strict>;
+export type PropertyDelta = z.infer<typeof PropertyDeltaSchema>;
+export interface DriftConflictError {
+    kind: "DriftConflictError";
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    deltas: PropertyDelta[];
+    baselineSource: "pr" | "persistent" | "file" | "unknown";
+    remediation?: string;
+}
+export interface DriftUnmergeableError {
+    kind: "DriftUnmergeableError";
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    reason: string;
+}
+export interface PermissionError {
+    kind: "PermissionError";
+    reason: "cross-account-peer-requires-trust" | "cross-org-connection-refused" | "unknown-remote-app" | "wildcard-principal-rejected" | "wildcard-resource-rejected";
+    details: string;
+    remediation?: string;
+}
+export type ControlFlowRefusalReason = "try-catch" | "switch-fall-through" | "nested-ternary" | "loop" | "generator-function" | "async-iterator" | "anonymous-helper" | "decorator-return";
+export interface ControlFlowClassifierError {
+    kind: "ControlFlowClassifierError";
+    reason: ControlFlowRefusalReason;
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    location?: {
+        line: number;
+        column: number;
+    };
+    remediation?: string;
+}
+export type LlmFallbackTier = "claude" | "morph";
+export interface LlmFallbackRejectedError {
+    kind: "LlmFallbackRejectedError";
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    diagnostics: string;
+}
+export interface LlmFallbackTimeoutError {
+    kind: "LlmFallbackTimeoutError";
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+}
+export interface LlmFallbackUnsafeInputError {
+    kind: "LlmFallbackUnsafeInputError";
+    reason: EgressRiskReason;
+    count: number;
+}
+export type CodemodError = ParseError | TemplateLiteralNameError | DuplicateResourceError | ResourceNotFoundError | ReferencesRemainError | InvalidPropertyError | SemanticQueryError | DriftConflictError | DriftUnmergeableError | PermissionError | ControlFlowClassifierError | LlmFallbackRejectedError | LlmFallbackTimeoutError | LlmFallbackUnsafeInputError;

package/dist/src/codemod/types.js

@@ -1 +1 @@
-import{z as e}from"zod";const t=e.enum(["database","storage","compute","messaging","cdn","network","pattern"]),n=e.string().regex(/^[A-Z][A-Za-z0-9]*$/,"Resource name must start with an uppercase letter and contain only alphanumerics (PascalCase)."),o=e.record(e.string(),e.unknown()),c=e.object({type:t,name:n,properties:o,filePath:e.string().optional()}).strict(),m=e.object({type:t,name:n,filePath:e.string().optional(),force:e.boolean().optional()}).strict(),p=e.object({type:t,name:n,properties:o,filePath:e.string().optional()}).strict(),r=e.object({line:e.number().int().nonnegative(),column:e.number().int().nonnegative(),context:e.string()}).strict(),a=e.object({added:e.number().int().nonnegative(),removed:e.number().int().nonnegative()}).strict(),i=e.object({type:t,name:e.string(),filePath:e.string(),start:e.number().int().nonnegative(),length:e.number().int().nonnegative()}).strict(),g=e.object({filePath:e.string(),resources:e.array(i)}).strict(),h=e.object({content:e.string(),linesChanged:a,references:e.array(r).optional(),warnings:e.array(e.string()).optional()}).strict();export{c as AddOptionsSchema,h as CodemodSuccessSchema,a as LinesChangedSchema,p as ModifyOptionsSchema,r as ReferenceLocationSchema,m as RemoveOptionsSchema,i as ResourceListingEntrySchema,g as ResourceListingSchema,n as ResourceNameSchema,t as StatementTypeSchema};
+import{z as t}from"zod";import{VALIDATION_MESSAGES as i,VALIDATION_PATTERNS as c}from"../validation/patterns.js";const o=t.object({force:t.boolean().optional(),resolutionMap:t.record(t.string(),t.unknown()).optional()}).strict(),e=t.enum(["database","storage","compute","messaging","cdn","network","pattern","vpc-peer","vpc-peer-accepter","cross-plan-connection"]),n=t.string().regex(c.PASCAL_CASE,i.PASCAL_CASE),r=t.record(t.string(),t.unknown()),g=t.object({type:e,name:n,properties:r,filePath:t.string().optional(),driftPolicy:o.optional(),branch:t.string().optional()}).strict(),h=t.object({type:e,name:n,filePath:t.string().optional(),force:t.boolean().optional(),branch:t.string().optional()}).strict(),b=t.object({type:e,name:n,properties:r,filePath:t.string().optional(),driftPolicy:o.optional(),branch:t.string().optional()}).strict(),a=t.object({line:t.number().int().positive(),column:t.number().int().positive(),context:t.string()}).strict(),s=t.object({added:t.number().int().nonnegative(),removed:t.number().int().nonnegative()}).strict(),p=t.object({type:e,name:t.string(),filePath:t.string(),start:t.number().int().nonnegative(),length:t.number().int().nonnegative()}).strict(),S=t.object({filePath:t.string(),resources:t.array(p)}).strict(),u=t.object({content:t.string(),linesChanged:s,references:t.array(a).optional(),warnings:t.array(t.string()).optional()}).strict(),d=t.object({property:t.string(),base:t.unknown().optional(),theirs:t.unknown(),ours:t.unknown(),verdict:t.enum(["clean","no-op","compatible","conflict"])}).strict();export{g as AddOptionsSchema,u as CodemodSuccessSchema,o as DriftPolicySchema,s as LinesChangedSchema,b as ModifyOptionsSchema,d as PropertyDeltaSchema,a as ReferenceLocationSchema,h as RemoveOptionsSchema,p as ResourceListingEntrySchema,S as ResourceListingSchema,n as ResourceNameSchema,e as StatementTypeSchema};

package/dist/src/codemod/validationGate/gates/classify.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const classifyGate: Gate;

package/dist/src/codemod/validationGate/gates/classify.js

@@ -0,0 +1 @@
+import{success as p,failure as y}from"../../../types/Result.js";import{parse as m}from"../../fileRewriter/parse.js";import{classifyControlFlow as h}from"../../semanticIndex/classifyControlFlow.js";import{locateAllShapes as A}from"../../semanticIndex/locateByShape.js";const C=new Set(["loc","tokens","comments","original","range"]);function f(o){return typeof o=="object"&&o!==null&&typeof o.type=="string"}function S(o,i){if(!f(o))return;const e=[{node:o,ancestors:[]}];for(;e.length>0;){const t=e.pop();if(t===void 0)continue;const{node:n,ancestors:s}=t;if(n.type==="StringLiteral"&&typeof n.start=="number"&&n.start===i)return{node:n,ancestors:s};const c=[...s,n];for(const u of Object.keys(n)){if(C.has(u))continue;const r=n[u];if(Array.isArray(r))for(let a=r.length-1;a>=0;a-=1){const l=r[a];f(l)&&e.push({node:l,ancestors:c})}else f(r)&&e.push({node:r,ancestors:c})}}}const g={conditional:"try-catch",loop:"loop","function-body":"anonymous-helper",unknown:"anonymous-helper"};function d(o){const i=A(o);if(!i.success)return[];const e=m(o);if(!e.success)return[];const t=[];for(const n of i.data){const s=S(e.data,n.start);if(s===void 0)continue;const c=h(s.node,s.ancestors);t.push({name:n.symbolName,type:n.type,classification:c})}return t}const O={id:"classify",run(o){if(o.inputContent===void 0)return p({action:"proceed"});const i=d(o.inputContent),e=d(o.content);for(const t of e){const n=i.find(s=>s.name===t.name&&s.type===t.type);if(n!==void 0&&n.classification==="top-level"&&t.classification!=="top-level")return y({kind:"ControlFlowClassifierError",reason:g[t.classification],resource:{type:t.type,name:t.name},location:void 0,remediation:"The LLM output moved a resource into a conditional or loop scope."})}return p({action:"proceed"})}};export{O as classifyGate};

package/dist/src/codemod/validationGate/gates/drift.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const driftGate: Gate;

package/dist/src/codemod/validationGate/gates/drift.js

@@ -0,0 +1 @@
+import{failure as i,success as o}from"../../../types/Result.js";import{detectDrift as n}from"../../drift/index.js";import{resolveDriftPolicy as f}from"../../edits/driftPolicy.js";const d={id:"drift",run(r){if(r.baseline===void 0)return o({action:"proceed"});const t=n(r.content,r.plan,r.baseline);if(!t.success)return i(t.error);const e=f(t.data,r.plan.op,r.policy);return e.action==="reject"?i({kind:"DriftConflictError",resource:e.driftState.resource,deltas:e.driftState.deltas,baselineSource:"file"}):o({action:e.action,driftState:e.driftState})}};export{d as driftGate};

package/dist/src/codemod/validationGate/gates/locate.d.ts

@@ -0,0 +1,7 @@
+import type { Gate } from "../types.js";
+export type LocateMode = "present" | "absent";
+export interface LocateGateOptions {
+    mode: LocateMode;
+}
+export declare function createLocateGate(options: LocateGateOptions): Gate;
+export declare const locateGate: Gate;

package/dist/src/codemod/validationGate/gates/locate.js

@@ -0,0 +1 @@
+import{success as o,failure as r}from"../../../types/Result.js";import{locateByShape as p}from"../../semanticIndex/locateByShape.js";function u(t){return{id:"locate",run(e){const n=p(e.content,{type:e.plan.type,name:e.plan.name});if(!n.success)return r(n.error);const a=n.data!==void 0;return t.mode==="present"&&!a?r({kind:"ResourceNotFoundError",type:e.plan.type,name:e.plan.name,knownNames:[]}):t.mode==="absent"&&a?r({kind:"DuplicateResourceError",type:e.plan.type,name:e.plan.name}):o({action:"proceed"})}}}const c=u({mode:"present"});export{u as createLocateGate,c as locateGate};

package/dist/src/codemod/validationGate/gates/parse.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const parseGate: Gate;

package/dist/src/codemod/validationGate/gates/parse.js

@@ -0,0 +1 @@
+import{success as o,failure as t}from"../../../types/Result.js";import{parse as i}from"../../fileRewriter/parse.js";const d={id:"parse",run(s){const r=i(s.content);if(!r.success){const e=r.error,n=e.line!==void 0&&e.column!==void 0?`${String(e.line)}:${String(e.column)}`:void 0;return t({...e,kind:"ParseError",message:n!==void 0?`${e.message} at ${n}`:e.message})}return o({action:"proceed"})}};export{d as parseGate};

package/dist/src/codemod/validationGate/gates/schema.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const schemaGate: Gate;

package/dist/src/codemod/validationGate/gates/schema.js

@@ -0,0 +1 @@
+import{success as c}from"../../../types/Result.js";const t={id:"schema",run(e){return c({action:"proceed"})}};export{t as schemaGate};

package/dist/src/codemod/validationGate/index.d.ts

@@ -0,0 +1,6 @@
+export { runPipeline, runPipelineAsync, type AsyncGate, type Gate, type GateAction, type GateContext, type GateId, type GateOutcome, type GateResult, } from "./types.js";
+export { driftGate } from "./gates/drift.js";
+export { schemaGate } from "./gates/schema.js";
+export { parseGate } from "./gates/parse.js";
+export { locateGate } from "./gates/locate.js";
+export { classifyGate } from "./gates/classify.js";

package/dist/src/codemod/validationGate/index.js

@@ -0,0 +1 @@
+import{runPipeline as o,runPipelineAsync as t}from"./types.js";import{driftGate as p}from"./gates/drift.js";import{schemaGate as m}from"./gates/schema.js";import{parseGate as x}from"./gates/parse.js";import{locateGate as s}from"./gates/locate.js";import{classifyGate as c}from"./gates/classify.js";export{c as classifyGate,p as driftGate,s as locateGate,x as parseGate,o as runPipeline,t as runPipelineAsync,m as schemaGate};

package/dist/src/codemod/validationGate/types.d.ts

@@ -0,0 +1,35 @@
+import { type Result } from "../../types/Result.js";
+import type { DriftOp, DriftPolicy, DriftState, ResourceSnapshot } from "../drift/index.js";
+import type { CodemodError, ResourceName, StatementType } from "../types.js";
+export type GateId = "parse" | "tsc" | "classify" | "locate" | "schema" | "drift" | "runtime";
+export type GateAction = "proceed" | "skip" | "reject";
+export interface GateContext {
+    content: string;
+    plan: {
+        type: StatementType;
+        name: ResourceName;
+        properties: Record<string, unknown>;
+        op: DriftOp;
+    };
+    baseline?: ResourceSnapshot;
+    policy?: DriftPolicy;
+    signal?: AbortSignal;
+    inputContent?: string;
+}
+export interface GateOutcome {
+    action: GateAction;
+    driftState?: DriftState;
+    failedGate?: GateId;
+    diagnostics?: string;
+}
+export type GateResult = Result<GateOutcome, CodemodError>;
+export interface Gate {
+    readonly id: GateId;
+    run(ctx: GateContext): GateResult;
+}
+export interface AsyncGate {
+    readonly id: GateId;
+    run(ctx: GateContext): Promise<GateResult>;
+}
+export declare function runPipeline(gates: readonly Gate[], ctx: GateContext): GateResult;
+export declare function runPipelineAsync(gates: ReadonlyArray<Gate | AsyncGate>, ctx: GateContext): Promise<GateResult>;

package/dist/src/codemod/validationGate/types.js

@@ -0,0 +1 @@
+import{success as o}from"../../types/Result.js";function i(n,r){for(const t of n){const e=t.run(r);if(!e.success||e.data.action!=="proceed")return e}return o({action:"proceed"})}async function a(n,r){for(const t of n){if(r.signal?.aborted===!0)return o({action:"reject",failedGate:t.id,diagnostics:"aborted"});const e=await t.run(r);if(!e.success||e.data.action!=="proceed")return e}return o({action:"proceed"})}export{i as runPipeline,a as runPipelineAsync};