local-serverless-stack 0.6.0 → 0.8.0

package/dist/server/engine/emulators/events/pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../../../../src/server/engine/emulators/events/pattern.ts"],"names":[],"mappings":"AAcA,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGjF;AAsDD,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAO1D"}

package/dist/server/engine/emulators/events/pattern.js

@@ -0,0 +1,125 @@
+// Pure EventBridge event-pattern matcher and validator (v1 subset — see
+// docs/PRD_SELF_ENGINE.md §RF6.1). Leaf arrays are an OR of exact values
+// (numbers compared numerically, everything else type-sensitive), {"prefix"}
+// and {"exists"}; nested pattern objects recurse into event fields. Operators
+// outside the v1 set are rejected up front by validatePattern (PutRule turns
+// them into InvalidEventPatternException) — matching never fails silently on
+// an operator the validator would have refused.
+const V1_OPERATORS = new Set(['prefix', 'exists']);
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function matches(pattern, event) {
+    if (!isPlainObject(pattern))
+        return false;
+    return matchObject(pattern, event);
+}
+function matchObject(pattern, event) {
+    // An event array satisfies a nested pattern when any element does.
+    if (Array.isArray(event))
+        return event.some(element => matchObject(pattern, element));
+    for (const [key, expected] of Object.entries(pattern)) {
+        const present = isPlainObject(event) && key in event;
+        const actual = present ? event[key] : undefined;
+        if (Array.isArray(expected)) {
+            if (!matchLeaf(expected, actual, present))
+                return false;
+        }
+        else if (isPlainObject(expected)) {
+            if (!present || !matchObject(expected, actual))
+                return false;
+        }
+        else {
+            // Bare primitives are invalid pattern shapes (validatePattern throws on
+            // them); a rule that somehow carries one must never match.
+            return false;
+        }
+    }
+    return true;
+}
+function matchLeaf(alternatives, actual, present) {
+    const candidates = Array.isArray(actual) ? actual : [actual];
+    return alternatives.some(alternative => {
+        if (isPlainObject(alternative)) {
+            const keys = Object.keys(alternative);
+            if (keys.length !== 1)
+                return false;
+            const operator = keys[0];
+            const argument = alternative[operator];
+            if (operator === 'exists')
+                return argument === true ? present : !present;
+            if (operator === 'prefix') {
+                return present && typeof argument === 'string'
+                    && candidates.some(value => typeof value === 'string' && value.startsWith(argument));
+            }
+            return false; // unsupported operator — rejected at PutRule time
+        }
+        return present && candidates.some(value => valueEquals(alternative, value));
+    });
+}
+// Exact-match semantics: numbers compare numerically (5 matches 5.0), every
+// other JSON primitive is type-sensitive strict equality ("5" never matches 5).
+function valueEquals(expected, actual) {
+    if (typeof expected === 'number')
+        return typeof actual === 'number' && expected === actual;
+    return expected === actual;
+}
+// Structural validation for PutRule. Returns the (deduplicated) operator names
+// used by the pattern that the v1 matcher does not support — suffix,
+// anything-but, numeric, cidr, equals-ignore-case, wildcard, or anything else
+// unknown — and an empty array when the pattern is fully supported. Throws a
+// plain Error on structurally invalid patterns (non-object root, empty
+// objects/arrays, bare primitive leaves, nested arrays, malformed operator
+// objects); callers wrap the message into InvalidEventPatternException.
+export function validatePattern(pattern) {
+    if (!isPlainObject(pattern)) {
+        throw new Error('Event pattern must be a JSON object.');
+    }
+    const unsupported = new Set();
+    walkPattern(pattern, '', unsupported);
+    return [...unsupported];
+}
+function walkPattern(pattern, path, unsupported) {
+    const entries = Object.entries(pattern);
+    if (entries.length === 0) {
+        throw new Error(`Event pattern must not contain an empty object${path ? ` at "${path}"` : ''}.`);
+    }
+    for (const [key, value] of entries) {
+        const keyPath = path ? `${path}.${key}` : key;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                throw new Error(`Match value list at "${keyPath}" must not be empty.`);
+            for (const alternative of value)
+                validateAlternative(alternative, keyPath, unsupported);
+        }
+        else if (isPlainObject(value)) {
+            walkPattern(value, keyPath, unsupported);
+        }
+        else {
+            throw new Error(`Pattern value at "${keyPath}" must be an array of match values or a nested object.`);
+        }
+    }
+}
+function validateAlternative(alternative, keyPath, unsupported) {
+    if (Array.isArray(alternative)) {
+        throw new Error(`Nested arrays are not allowed in the match value list at "${keyPath}".`);
+    }
+    if (!isPlainObject(alternative))
+        return; // exact-match primitive — always supported
+    const keys = Object.keys(alternative);
+    if (keys.length !== 1) {
+        throw new Error(`Match operator objects must have exactly one key (at "${keyPath}").`);
+    }
+    const operator = keys[0];
+    if (!V1_OPERATORS.has(operator)) {
+        unsupported.add(operator);
+        return;
+    }
+    if (operator === 'prefix' && typeof alternative[operator] !== 'string') {
+        throw new Error(`Operator "prefix" at "${keyPath}" requires a string argument.`);
+    }
+    if (operator === 'exists' && typeof alternative[operator] !== 'boolean') {
+        throw new Error(`Operator "exists" at "${keyPath}" requires a boolean argument.`);
+    }
+}
+//# sourceMappingURL=pattern.js.map

package/dist/server/engine/emulators/events/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../../../../src/server/engine/emulators/events/pattern.ts"],"names":[],"mappings":"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"}

package/dist/server/engine/emulators/lambda-ctl/index.d.ts

@@ -0,0 +1,55 @@
+import type { AwsRequest, AwsResponse, EngineContext, EngineEventSourceMappingRecord, EngineFunctionRecord, EngineServiceName, RestEmulator } from '../../types.js';
+export interface LambdaPolicyStatement {
+    Sid: string;
+    Effect: 'Allow';
+    Action?: string;
+    Resource: string;
+    Principal?: {
+        Service: string;
+    };
+    Condition?: {
+        ArnLike: {
+            'AWS:SourceArn': string;
+        };
+    };
+}
+export interface LambdaFunctionRecord extends EngineFunctionRecord {
+    statements?: Record<string, LambdaPolicyStatement>;
+}
+export declare class LambdaCtlEmulator implements RestEmulator {
+    readonly service: EngineServiceName;
+    private readonly ctx;
+    private readonly esmChangedListeners;
+    constructor(ctx: EngineContext);
+    listEventSourceMappings(region: string): EngineEventSourceMappingRecord[];
+    getFunctionRecord(region: string, name: string): LambdaFunctionRecord | undefined;
+    onEsmChanged(cb: (region: string) => void): void;
+    ensureLoaded(region: string): Promise<void>;
+    handle(req: AwsRequest): Promise<AwsResponse>;
+    private handleFunctionRoutes;
+    private handleMappingRoutes;
+    private createFunction;
+    private getFunction;
+    private updateFunctionConfiguration;
+    private deleteFunction;
+    private listFunctions;
+    private addPermission;
+    private removePermission;
+    private createEventSourceMapping;
+    private listEventSourceMappingsRoute;
+    private updateEventSourceMapping;
+    private deleteEventSourceMapping;
+    private invoke;
+    private isUnresolved;
+    private functions;
+    private mappings;
+    private resolveFunctionName;
+    private functionArn;
+    private requireFunction;
+    private functionNotFound;
+    private requireMapping;
+    private functionConfiguration;
+    private mappingJson;
+    private fireEsmChanged;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/server/engine/emulators/lambda-ctl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/engine/emulators/lambda-ctl/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,aAAa,EACb,8BAA8B,EAC9B,oBAAoB,EAEpB,iBAAiB,EACjB,YAAY,EACb,MAAM,gBAAgB,CAAC;AAIxB,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,eAAe,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACtD;AAED,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CACpD;AA+ED,qBAAa,iBAAkB,YAAW,YAAY;IACpD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAY;IAE/C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuC;gBAE/D,GAAG,EAAE,aAAa;IAU9B,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,8BAA8B,EAAE;IAIzE,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAMjF,YAAY,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAI1C,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3C,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;YAYrC,oBAAoB;IAmBlC,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,cAAc;IAyBtB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,2BAA2B;IAgBnC,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,aAAa;IA8BrB,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,wBAAwB;IA8ChC,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,wBAAwB;IAmBhC,OAAO,CAAC,wBAAwB;YAWlB,MAAM;IA4CpB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,qBAAqB;IAgB7B,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,cAAc;CASvB"}

package/dist/server/engine/emulators/lambda-ctl/index.js

@@ -0,0 +1,461 @@
+// Lambda control-plane emulator for the self engine. Real functions run in
+// the LSS Lambda runtime; this emulator absorbs the provisioner's
+// LocalStack-era proxy functions as pure metadata (Code.ZipFile is discarded,
+// the INVOKE_URL env survives as the dispatcher's HTTP fallback), owns the
+// event source mapping registry the dispatcher delivers from, and passes
+// Invoke through to the dispatcher. REST-JSON on the /2015-03-31 paths the
+// LSS provisioner and QueueInspector call — see docs/PRD_SELF_ENGINE.md §6.
+import { randomUUID } from 'crypto';
+import { AwsError, notImplemented } from '../../http/errors.js';
+// Failed dispatcher results with these errorType values mean "the ref could
+// not be resolved at all" (vs a handler error, which stays a 200 +
+// X-Amz-Function-Error). The dispatcher contract never throws, so this is the
+// only signal available to turn an unknown function into the 404 the
+// provisioner's ensureLambdaProxyExists branches on.
+// 'FunctionNotResolvable' is what the round-2 dispatcher actually emits for
+// refs it cannot resolve anywhere (registry, catalog, INVOKE_URL).
+const UNRESOLVED_ERROR_TYPES = new Set([
+    'ResourceNotFoundException',
+    'FunctionNotFound',
+    'Function.NotFound',
+    'FunctionNotResolvable',
+]);
+const SOURCE_LABELS = { sqs: 'SQS', dynamodb: 'DynamoDB', kinesis: 'Kinesis' };
+function sourceLabel(arn) {
+    const service = arn.split(':')[2] ?? '';
+    return SOURCE_LABELS[service] ?? service.toUpperCase();
+}
+function decodeSegment(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+}
+function parseJsonBody(req) {
+    if (req.body.length === 0)
+        return {};
+    try {
+        return JSON.parse(req.body.toString('utf8'));
+    }
+    catch {
+        throw new AwsError('InvalidRequestContentException', 'Could not parse request body into json', { status: 400 });
+    }
+}
+function jsonResponse(status, payload) {
+    return { status, headers: { 'content-type': 'application/json' }, body: JSON.stringify(payload) };
+}
+// Lambda's LastModified format ("2026-07-10T12:00:00.000+0000").
+function awsTimestamp(iso) {
+    return new Date(iso).toISOString().replace('Z', '+0000');
+}
+export class LambdaCtlEmulator {
+    service = 'lambda';
+    ctx;
+    esmChangedListeners = [];
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // -------------------------------------------------------------------------
+    // Dispatcher-facing API (round-2 wiring)
+    // -------------------------------------------------------------------------
+    // Both sync accessors read the loaded catalog state; callers outside a
+    // request (dispatcher boot re-arm) must `await ensureLoaded(region)` first.
+    listEventSourceMappings(region) {
+        return this.mappings(region).values();
+    }
+    getFunctionRecord(region, name) {
+        return this.functions(region).get(this.resolveFunctionName(name));
+    }
+    // Fired after every ESM create/update/delete (including the cascade drop on
+    // DeleteFunction) so the dispatcher re-syncs its delivery loops.
+    onEsmChanged(cb) {
+        this.esmChangedListeners.push(cb);
+    }
+    async ensureLoaded(region) {
+        await Promise.all([this.functions(region).load(), this.mappings(region).load()]);
+    }
+    // -------------------------------------------------------------------------
+    // Routing
+    // -------------------------------------------------------------------------
+    async handle(req) {
+        const segments = req.rawPath.split('/').filter(s => s.length > 0).map(decodeSegment);
+        if (segments[0] !== '2015-03-31') {
+            throw notImplemented('lambda', `${req.method} ${req.rawPath}`);
+        }
+        await this.ensureLoaded(req.region);
+        const [, root, ...rest] = segments;
+        if (root === 'functions')
+            return this.handleFunctionRoutes(req, rest);
+        if (root === 'event-source-mappings')
+            return this.handleMappingRoutes(req, rest);
+        throw notImplemented('lambda', `${req.method} ${req.rawPath}`);
+    }
+    async handleFunctionRoutes(req, rest) {
+        if (rest.length === 0) {
+            if (req.method === 'POST')
+                return this.createFunction(req);
+            if (req.method === 'GET')
+                return this.listFunctions(req);
+        }
+        else if (rest.length === 1) {
+            if (req.method === 'GET')
+                return this.getFunction(req, rest[0]);
+            if (req.method === 'DELETE')
+                return this.deleteFunction(req, rest[0]);
+        }
+        else if (rest.length === 2 && rest[1] === 'configuration' && req.method === 'PUT') {
+            return this.updateFunctionConfiguration(req, rest[0]);
+        }
+        else if (rest.length === 2 && rest[1] === 'policy' && req.method === 'POST') {
+            return this.addPermission(req, rest[0]);
+        }
+        else if (rest.length === 3 && rest[1] === 'policy' && req.method === 'DELETE') {
+            return this.removePermission(req, rest[0], rest[2]);
+        }
+        else if (rest.length === 2 && rest[1] === 'invocations' && req.method === 'POST') {
+            return this.invoke(req, rest[0]);
+        }
+        throw notImplemented('lambda', `${req.method} ${req.rawPath}`);
+    }
+    handleMappingRoutes(req, rest) {
+        if (rest.length === 0) {
+            if (req.method === 'POST')
+                return this.createEventSourceMapping(req);
+            if (req.method === 'GET')
+                return this.listEventSourceMappingsRoute(req);
+        }
+        else if (rest.length === 1) {
+            if (req.method === 'GET')
+                return jsonResponse(200, this.mappingJson(req.region, this.requireMapping(req.region, rest[0])));
+            if (req.method === 'PUT')
+                return this.updateEventSourceMapping(req, rest[0]);
+            if (req.method === 'DELETE')
+                return this.deleteEventSourceMapping(req, rest[0]);
+        }
+        throw notImplemented('lambda', `${req.method} ${req.rawPath}`);
+    }
+    // -------------------------------------------------------------------------
+    // Functions
+    // -------------------------------------------------------------------------
+    createFunction(req) {
+        const input = parseJsonBody(req);
+        const name = input.FunctionName;
+        if (!name) {
+            throw new AwsError('ValidationException', 'FunctionName is required', { status: 400 });
+        }
+        const catalog = this.functions(req.region);
+        if (catalog.get(name)) {
+            throw new AwsError('ResourceConflictException', `Function already exist: ${name}`, { status: 409 });
+        }
+        // Code.ZipFile is intentionally never read: absorbed proxies are metadata.
+        const record = {
+            functionName: name,
+            arn: this.functionArn(req.region, name),
+            runtime: input.Runtime,
+            handler: input.Handler,
+            memorySize: input.MemorySize,
+            timeout: input.Timeout,
+            environment: input.Environment?.Variables ?? {},
+            lastModified: new Date().toISOString(),
+        };
+        catalog.set(name, record);
+        return jsonResponse(201, this.functionConfiguration(record));
+    }
+    getFunction(req, ref) {
+        const record = this.requireFunction(req.region, this.resolveFunctionName(ref));
+        return jsonResponse(200, { Configuration: this.functionConfiguration(record), Code: {} });
+    }
+    updateFunctionConfiguration(req, ref) {
+        const name = this.resolveFunctionName(ref);
+        const record = this.requireFunction(req.region, name);
+        const input = parseJsonBody(req);
+        // AWS replaces Environment.Variables wholesale when Environment is sent —
+        // this is how the provisioner re-points stale INVOKE_URLs.
+        if (input.Environment !== undefined)
+            record.environment = input.Environment.Variables ?? {};
+        if (input.Runtime !== undefined)
+            record.runtime = input.Runtime;
+        if (input.Handler !== undefined)
+            record.handler = input.Handler;
+        if (input.MemorySize !== undefined)
+            record.memorySize = input.MemorySize;
+        if (input.Timeout !== undefined)
+            record.timeout = input.Timeout;
+        record.lastModified = new Date().toISOString();
+        this.functions(req.region).set(name, record);
+        return jsonResponse(200, this.functionConfiguration(record));
+    }
+    deleteFunction(req, ref) {
+        const name = this.resolveFunctionName(ref);
+        this.requireFunction(req.region, name);
+        this.functions(req.region).delete(name);
+        const mappings = this.mappings(req.region);
+        let dropped = false;
+        for (const mapping of mappings.values()) {
+            if (mapping.functionName === name) {
+                mappings.delete(mapping.uuid);
+                dropped = true;
+            }
+        }
+        if (dropped)
+            this.fireEsmChanged(req.region);
+        return { status: 204 };
+    }
+    listFunctions(req) {
+        const functions = this.functions(req.region).values().map(record => this.functionConfiguration(record));
+        return jsonResponse(200, { Functions: functions });
+    }
+    // -------------------------------------------------------------------------
+    // Permissions (recorded no-ops — nothing enforces them locally)
+    // -------------------------------------------------------------------------
+    addPermission(req, ref) {
+        const name = this.resolveFunctionName(ref);
+        const record = this.requireFunction(req.region, name);
+        const input = parseJsonBody(req);
+        const sid = input.StatementId;
+        if (!sid) {
+            throw new AwsError('ValidationException', 'StatementId is required', { status: 400 });
+        }
+        const statements = record.statements ?? {};
+        if (statements[sid]) {
+            throw new AwsError('ResourceConflictException', `The statement id (${sid}) provided already exists. Please provide new statement id, or remove existing statement.`, { status: 409 });
+        }
+        const statement = {
+            Sid: sid,
+            Effect: 'Allow',
+            Resource: record.arn,
+            ...(input.Action !== undefined ? { Action: input.Action } : {}),
+            ...(input.Principal !== undefined ? { Principal: { Service: input.Principal } } : {}),
+            ...(input.SourceArn !== undefined ? { Condition: { ArnLike: { 'AWS:SourceArn': input.SourceArn } } } : {}),
+        };
+        statements[sid] = statement;
+        record.statements = statements;
+        this.functions(req.region).set(name, record);
+        return jsonResponse(201, { Statement: JSON.stringify(statement) });
+    }
+    removePermission(req, ref, sid) {
+        const name = this.resolveFunctionName(ref);
+        const record = this.requireFunction(req.region, name);
+        if (!record.statements || !record.statements[sid]) {
+            throw new AwsError('ResourceNotFoundException', `Statement ${sid} is not found in resource policy.`, { status: 404 });
+        }
+        delete record.statements[sid];
+        this.functions(req.region).set(name, record);
+        return { status: 204 };
+    }
+    // -------------------------------------------------------------------------
+    // Event source mappings
+    // -------------------------------------------------------------------------
+    createEventSourceMapping(req) {
+        const input = parseJsonBody(req);
+        if (!input.FunctionName) {
+            throw new AwsError('ValidationException', 'FunctionName is required', { status: 400 });
+        }
+        const functionName = this.resolveFunctionName(input.FunctionName);
+        const eventSourceArn = input.EventSourceArn;
+        if (!eventSourceArn) {
+            throw new AwsError('InvalidParameterValueException', 'Unrecognized event source, must be kinesis, sqs or dynamodb stream.', { status: 400 });
+        }
+        const catalog = this.mappings(req.region);
+        const existing = catalog.values().find(m => m.eventSourceArn === eventSourceArn && m.functionName === functionName);
+        if (existing) {
+            throw new AwsError('ResourceConflictException', `An event source mapping with ${sourceLabel(eventSourceArn)} arn (" ${eventSourceArn} ") and function ` +
+                `(" ${functionName} ") already exists. Please use the existing mapping with UUID ${existing.uuid}`, { status: 409 });
+        }
+        const now = new Date().toISOString();
+        const enabled = input.Enabled !== false;
+        const record = {
+            uuid: randomUUID(),
+            functionName,
+            eventSourceArn,
+            enabled,
+            batchSize: input.BatchSize ?? 10,
+            maximumBatchingWindowInSeconds: input.MaximumBatchingWindowInSeconds,
+            maximumRetryAttempts: input.MaximumRetryAttempts,
+            startingPosition: input.StartingPosition,
+            onFailureDestinationArn: input.DestinationConfig?.OnFailure?.Destination,
+            filterCriteria: input.FilterCriteria,
+            createdAt: now,
+            lastModified: now,
+            state: enabled ? 'Enabled' : 'Disabled',
+        };
+        catalog.set(record.uuid, record);
+        this.fireEsmChanged(req.region);
+        return jsonResponse(202, this.mappingJson(req.region, record));
+    }
+    listEventSourceMappingsRoute(req) {
+        const arnFilter = req.query['EventSourceArn'];
+        const rawFunctionFilter = req.query['FunctionName'];
+        const functionFilter = rawFunctionFilter ? this.resolveFunctionName(rawFunctionFilter) : undefined;
+        let records = this.mappings(req.region).values();
+        if (arnFilter)
+            records = records.filter(m => m.eventSourceArn === arnFilter);
+        if (functionFilter)
+            records = records.filter(m => m.functionName === functionFilter);
+        return jsonResponse(200, { EventSourceMappings: records.map(m => this.mappingJson(req.region, m)) });
+    }
+    updateEventSourceMapping(req, uuid) {
+        const record = this.requireMapping(req.region, uuid);
+        const input = parseJsonBody(req);
+        if (typeof input.Enabled === 'boolean') {
+            record.enabled = input.Enabled;
+            record.state = input.Enabled ? 'Enabled' : 'Disabled';
+        }
+        if (input.BatchSize !== undefined)
+            record.batchSize = input.BatchSize;
+        if (input.MaximumBatchingWindowInSeconds !== undefined)
+            record.maximumBatchingWindowInSeconds = input.MaximumBatchingWindowInSeconds;
+        if (input.MaximumRetryAttempts !== undefined)
+            record.maximumRetryAttempts = input.MaximumRetryAttempts;
+        if (input.FunctionName !== undefined)
+            record.functionName = this.resolveFunctionName(input.FunctionName);
+        if (input.FilterCriteria !== undefined)
+            record.filterCriteria = input.FilterCriteria;
+        if (input.DestinationConfig !== undefined)
+            record.onFailureDestinationArn = input.DestinationConfig.OnFailure?.Destination;
+        record.lastModified = new Date().toISOString();
+        this.mappings(req.region).set(uuid, record);
+        this.fireEsmChanged(req.region);
+        return jsonResponse(202, this.mappingJson(req.region, record));
+    }
+    deleteEventSourceMapping(req, uuid) {
+        const record = this.requireMapping(req.region, uuid);
+        this.mappings(req.region).delete(uuid);
+        this.fireEsmChanged(req.region);
+        return jsonResponse(202, this.mappingJson(req.region, record));
+    }
+    // -------------------------------------------------------------------------
+    // Invoke passthrough
+    // -------------------------------------------------------------------------
+    async invoke(req, ref) {
+        const name = this.resolveFunctionName(ref);
+        const invocationType = req.headers['x-amz-invocation-type'] || 'RequestResponse';
+        const record = this.functions(req.region).get(name);
+        if (invocationType === 'DryRun') {
+            // No registry probe without invoking, so catalog presence is the check.
+            if (!record)
+                throw this.functionNotFound(req.region, name);
+            return { status: 204 };
+        }
+        let event = {};
+        if (req.body.length > 0) {
+            try {
+                event = JSON.parse(req.body.toString('utf8'));
+            }
+            catch {
+                throw new AwsError('InvalidRequestContentException', 'Could not parse request body into json', { status: 400 });
+            }
+        }
+        const result = await this.ctx.dispatcher.invokeFunction(name, event, { async: invocationType === 'Event' });
+        if (!record && this.isUnresolved(result)) {
+            throw this.functionNotFound(req.region, name);
+        }
+        if (invocationType === 'Event') {
+            return { status: 202, headers: { 'content-type': 'application/json' } };
+        }
+        if (!result.ok) {
+            return {
+                status: 200,
+                headers: { 'content-type': 'application/json', 'x-amz-function-error': 'Unhandled' },
+                body: JSON.stringify({
+                    errorType: result.errorType ?? 'Error',
+                    errorMessage: result.errorMessage ?? 'Unhandled error',
+                }),
+            };
+        }
+        return {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+            body: result.payload === undefined || result.payload === null ? 'null' : JSON.stringify(result.payload),
+        };
+    }
+    isUnresolved(result) {
+        return !result.ok && result.errorType !== undefined && UNRESOLVED_ERROR_TYPES.has(result.errorType);
+    }
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    functions(region) {
+        return this.ctx.store.catalog(`lambda/${region}/functions`);
+    }
+    mappings(region) {
+        return this.ctx.store.catalog(`lambda/${region}/event-source-mappings`);
+    }
+    // Accepts a bare name, "name:qualifier", or a full/partial function ARN and
+    // returns the bare name — records are always keyed by name.
+    resolveFunctionName(ref) {
+        if (!ref.startsWith('arn:'))
+            return ref.split(':')[0];
+        const suffix = ref.split(':function:')[1];
+        return suffix ? suffix.split(':')[0] : ref;
+    }
+    functionArn(region, name) {
+        return `arn:aws:lambda:${region}:${this.ctx.config.account}:function:${name}`;
+    }
+    requireFunction(region, name) {
+        const record = this.functions(region).get(name);
+        if (!record)
+            throw this.functionNotFound(region, name);
+        return record;
+    }
+    functionNotFound(region, name) {
+        return new AwsError('ResourceNotFoundException', `Function not found: ${this.functionArn(region, name)}`, { status: 404 });
+    }
+    requireMapping(region, uuid) {
+        const record = this.mappings(region).get(uuid);
+        if (!record) {
+            throw new AwsError('ResourceNotFoundException', 'The resource you requested does not exist.', { status: 404 });
+        }
+        return record;
+    }
+    functionConfiguration(record) {
+        return {
+            FunctionName: record.functionName,
+            FunctionArn: record.arn,
+            Runtime: record.runtime,
+            Handler: record.handler,
+            MemorySize: record.memorySize,
+            Timeout: record.timeout,
+            Environment: { Variables: record.environment },
+            Version: '$LATEST',
+            State: 'Active',
+            LastUpdateStatus: 'Successful',
+            LastModified: awsTimestamp(record.lastModified),
+        };
+    }
+    mappingJson(region, record) {
+        const json = {
+            UUID: record.uuid,
+            BatchSize: record.batchSize,
+            MaximumBatchingWindowInSeconds: record.maximumBatchingWindowInSeconds ?? 0,
+            EventSourceArn: record.eventSourceArn,
+            FunctionArn: this.functionArn(region, record.functionName),
+            LastModified: Math.floor(Date.parse(record.lastModified) / 1000),
+            State: record.state,
+            StateTransitionReason: 'USER_INITIATED',
+        };
+        if (record.startingPosition !== undefined)
+            json.StartingPosition = record.startingPosition;
+        if (record.maximumRetryAttempts !== undefined)
+            json.MaximumRetryAttempts = record.maximumRetryAttempts;
+        if (record.onFailureDestinationArn !== undefined) {
+            json.DestinationConfig = { OnFailure: { Destination: record.onFailureDestinationArn } };
+        }
+        if (record.filterCriteria !== undefined)
+            json.FilterCriteria = record.filterCriteria;
+        return json;
+    }
+    fireEsmChanged(region) {
+        for (const listener of this.esmChangedListeners) {
+            try {
+                listener(region);
+            }
+            catch (err) {
+                console.warn(`lambda-ctl: onEsmChanged listener failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=index.js.map