@stackwright-services/runtime 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1138 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/messaging/sqs-sns.ts
+var sqs_sns_exports = {};
+__export(sqs_sns_exports, {
+  SqsSnsMessageBusProvider: () => SqsSnsMessageBusProvider,
+  toUpperSnake: () => toUpperSnake
+});
+import {
+  SNSClient,
+  PublishCommand
+} from "@aws-sdk/client-sns";
+import {
+  SQSClient,
+  ReceiveMessageCommand,
+  DeleteMessageCommand
+} from "@aws-sdk/client-sqs";
+function toUpperSnake(name) {
+  return name.replace(/[-.]/g, "_").toUpperCase();
+}
+var LOG_PREFIX, SqsSnsMessageBusProvider;
+var init_sqs_sns = __esm({
+  "src/messaging/sqs-sns.ts"() {
+    "use strict";
+    LOG_PREFIX = "stackwright-services:messaging";
+    SqsSnsMessageBusProvider = class {
+      snsClient;
+      sqsClient;
+      topicArns;
+      queueUrls;
+      waitTimeSeconds;
+      maxMessages;
+      pollIntervalMs;
+      pollingStates = /* @__PURE__ */ new Map();
+      constructor(config = {}) {
+        const region = config.region ?? process.env["AWS_REGION"] ?? "us-east-1";
+        this.snsClient = config.snsClient ?? new SNSClient({ region });
+        this.sqsClient = config.sqsClient ?? new SQSClient({ region });
+        this.topicArns = config.topicArns ?? {};
+        this.queueUrls = config.queueUrls ?? {};
+        this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+        this.maxMessages = config.maxMessages ?? 10;
+        this.pollIntervalMs = config.pollIntervalMs ?? 100;
+      }
+      async publish(topic, message) {
+        const topicArn = this.resolveTopicArn(topic);
+        const attributes = this.buildSnsAttributes(message);
+        const input = {
+          TopicArn: topicArn,
+          Message: JSON.stringify(message.payload),
+          MessageAttributes: attributes
+        };
+        const response = await this.snsClient.send(new PublishCommand(input));
+        const messageId = response.MessageId ?? `sns-${Date.now()}`;
+        return { messageId, topic, success: true };
+      }
+      async subscribe(topic, handler) {
+        const queueUrl = this.resolveQueueUrl(topic);
+        const id = `sqs-sub-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const state = { active: true };
+        this.pollingStates.set(id, state);
+        this.poll(queueUrl, handler, state);
+        const cancel = async () => {
+          await this.unsubscribe({ id, topic, cancel: async () => {
+          } });
+        };
+        return { id, topic, cancel };
+      }
+      async unsubscribe(subscription) {
+        const state = this.pollingStates.get(subscription.id);
+        if (state) {
+          state.active = false;
+          this.pollingStates.delete(subscription.id);
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // Private helpers
+      // ---------------------------------------------------------------------------
+      resolveTopicArn(topic) {
+        const fromConfig = this.topicArns[topic];
+        if (fromConfig) return fromConfig;
+        const envKey = `BUS_TOPIC_${toUpperSnake(topic)}_ARN`;
+        const fromEnv = process.env[envKey];
+        if (fromEnv) return fromEnv;
+        throw new Error(
+          `${LOG_PREFIX} No SNS Topic ARN found for "${topic}". Set config.topicArns["${topic}"] or env var ${envKey}.`
+        );
+      }
+      resolveQueueUrl(topic) {
+        const fromConfig = this.queueUrls[topic];
+        if (fromConfig) return fromConfig;
+        const envKey = `BUS_QUEUE_${toUpperSnake(topic)}_URL`;
+        const fromEnv = process.env[envKey];
+        if (fromEnv) return fromEnv;
+        throw new Error(
+          `${LOG_PREFIX} No SQS Queue URL found for "${topic}". Set config.queueUrls["${topic}"] or env var ${envKey}.`
+        );
+      }
+      buildSnsAttributes(message) {
+        const attrs = {};
+        if (message.traceContext) {
+          for (const [key, value] of Object.entries(message.traceContext)) {
+            attrs[`trace.${key}`] = { DataType: "String", StringValue: value };
+          }
+        }
+        if (message.metadata) {
+          const { timestamp, source, correlationId } = message.metadata;
+          if (timestamp) {
+            attrs["meta.timestamp"] = { DataType: "String", StringValue: timestamp };
+          }
+          if (source) {
+            attrs["meta.source"] = { DataType: "String", StringValue: source };
+          }
+          if (correlationId) {
+            attrs["meta.correlationId"] = { DataType: "String", StringValue: correlationId };
+          }
+        }
+        return attrs;
+      }
+      async poll(queueUrl, handler, state) {
+        while (state.active) {
+          await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+          if (!state.active) break;
+          try {
+            const response = await this.sqsClient.send(
+              new ReceiveMessageCommand({
+                QueueUrl: queueUrl,
+                WaitTimeSeconds: this.waitTimeSeconds,
+                MaxNumberOfMessages: this.maxMessages,
+                MessageAttributeNames: ["All"]
+              })
+            );
+            for (const sqsMessage of response.Messages ?? []) {
+              if (!state.active) break;
+              const busMessage = this.parseSqsMessage(sqsMessage);
+              try {
+                await handler(busMessage);
+              } catch (handlerError) {
+                console.error(
+                  JSON.stringify({
+                    prefix: LOG_PREFIX,
+                    event: "handler_error",
+                    error: handlerError instanceof Error ? handlerError.message : String(handlerError),
+                    queueUrl
+                  })
+                );
+                continue;
+              }
+              if (sqsMessage.ReceiptHandle) {
+                await this.sqsClient.send(
+                  new DeleteMessageCommand({
+                    QueueUrl: queueUrl,
+                    ReceiptHandle: sqsMessage.ReceiptHandle
+                  })
+                );
+              }
+            }
+          } catch (pollError) {
+            console.error(
+              JSON.stringify({
+                prefix: LOG_PREFIX,
+                event: "poll_error",
+                error: pollError instanceof Error ? pollError.message : String(pollError),
+                queueUrl
+              })
+            );
+          }
+        }
+      }
+      parseSqsMessage(sqsMessage) {
+        const payload = sqsMessage.Body ? JSON.parse(sqsMessage.Body) : null;
+        const traceContext = this.extractTraceContext(sqsMessage.MessageAttributes);
+        const metadata = this.extractMetadata(sqsMessage.MessageAttributes);
+        return {
+          payload,
+          ...traceContext !== void 0 && { traceContext },
+          ...metadata !== void 0 && { metadata }
+        };
+      }
+      extractTraceContext(attrs) {
+        if (!attrs) return void 0;
+        const trace = {};
+        for (const [key, value] of Object.entries(attrs)) {
+          if (key.startsWith("trace.") && value.StringValue) {
+            trace[key.slice("trace.".length)] = value.StringValue;
+          }
+        }
+        return Object.keys(trace).length > 0 ? trace : void 0;
+      }
+      extractMetadata(attrs) {
+        if (!attrs) return void 0;
+        const timestamp = attrs["meta.timestamp"]?.StringValue;
+        const source = attrs["meta.source"]?.StringValue;
+        const correlationId = attrs["meta.correlationId"]?.StringValue;
+        if (!timestamp && !source && !correlationId) return void 0;
+        return {
+          ...timestamp && { timestamp },
+          ...source && { source },
+          ...correlationId && { correlationId }
+        };
+      }
+    };
+  }
+});
+
+// src/triggers/http.ts
+import { Hono } from "hono";
+function createHttpTrigger(options) {
+  const { trigger, handler, inputSchema, outputSchema } = options;
+  const app = new Hono();
+  app.get("/health", (c) => c.json({ status: "ok", trigger: "http" }));
+  const method = trigger.method.toLowerCase();
+  app[method](trigger.path, async (c) => {
+    let input;
+    if (trigger.method === "GET") {
+      input = Object.fromEntries(new URL(c.req.url).searchParams);
+    } else {
+      try {
+        input = await c.req.json();
+      } catch {
+        return c.json(
+          { error: "Invalid JSON body", code: "INVALID_REQUEST_BODY" },
+          400
+        );
+      }
+    }
+    if (inputSchema) {
+      const result = inputSchema.safeParse(input);
+      if (!result.success) {
+        return c.json(
+          {
+            error: "Input validation failed",
+            code: "VALIDATION_ERROR",
+            details: result.error.issues
+          },
+          400
+        );
+      }
+      input = result.data;
+    }
+    const context = {
+      traceId: c.req.header("x-trace-id") ?? c.req.header("x-request-id") ?? crypto.randomUUID(),
+      logger: createLogger()
+    };
+    try {
+      const result = await handler(input, context);
+      if (outputSchema) {
+        const outputResult = outputSchema.safeParse(result);
+        if (!outputResult.success) {
+          return c.json(
+            { error: "Output validation failed", code: "OUTPUT_VALIDATION_ERROR" },
+            500
+          );
+        }
+        return c.json(outputResult.data);
+      }
+      return c.json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return c.json({ error: message, code: "FLOW_EXECUTION_ERROR" }, 500);
+    }
+  });
+  return app;
+}
+function createLogger() {
+  return {
+    debug: (msg, data) => console.debug(JSON.stringify({ level: "debug", msg, ...data })),
+    info: (msg, data) => console.info(JSON.stringify({ level: "info", msg, ...data })),
+    warn: (msg, data) => console.warn(JSON.stringify({ level: "warn", msg, ...data })),
+    error: (msg, data) => console.error(JSON.stringify({ level: "error", msg, ...data }))
+  };
+}
+
+// src/triggers/event.ts
+var EventTriggerAdapter = class {
+  type = "event";
+  topic;
+  messageBus;
+  handler;
+  inputSchema;
+  subscription;
+  constructor(options) {
+    this.topic = options.trigger.source.replace(/^bus:/, "");
+    this.messageBus = options.messageBus;
+    this.handler = options.handler;
+    this.inputSchema = options.inputSchema;
+  }
+  async start() {
+    this.subscription = await this.messageBus.subscribe(
+      this.topic,
+      (message) => this.handleMessage(message)
+    );
+  }
+  async stop() {
+    if (this.subscription) {
+      await this.subscription.cancel();
+      this.subscription = void 0;
+    }
+  }
+  async handleMessage(message) {
+    let payload = message.payload;
+    if (this.inputSchema) {
+      const result = this.inputSchema.safeParse(payload);
+      if (!result.success) {
+        const logger = createLogger2();
+        logger.warn("Event payload validation failed", {
+          topic: this.topic,
+          errors: result.error.issues
+        });
+        return;
+      }
+      payload = result.data;
+    }
+    const traceId = message.traceContext?.["traceId"] ?? crypto.randomUUID();
+    const context = {
+      traceId,
+      logger: createLogger2()
+    };
+    try {
+      await this.handler(payload, context);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      context.logger.error("Event handler failed", {
+        topic: this.topic,
+        error: errorMessage
+      });
+    }
+  }
+};
+function createLogger2() {
+  return {
+    debug: (msg, data) => console.debug(JSON.stringify({ level: "debug", msg, ...data })),
+    info: (msg, data) => console.info(JSON.stringify({ level: "info", msg, ...data })),
+    warn: (msg, data) => console.warn(JSON.stringify({ level: "warn", msg, ...data })),
+    error: (msg, data) => console.error(JSON.stringify({ level: "error", msg, ...data }))
+  };
+}
+
+// src/triggers/schedule.ts
+var DEFAULT_INTERVAL_MS = 6e4;
+var ScheduleTriggerAdapter = class {
+  type = "schedule";
+  cron;
+  handler;
+  inputSchema;
+  intervalMs;
+  timer;
+  constructor(options) {
+    this.cron = options.trigger.cron;
+    this.handler = options.handler;
+    this.inputSchema = options.inputSchema;
+    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  }
+  async start() {
+    if (this.intervalMs === DEFAULT_INTERVAL_MS) {
+      const logger = createLogger3();
+      logger.warn("Cron parsing not built-in; using default 60s interval for local dev", {
+        cron: this.cron,
+        intervalMs: this.intervalMs
+      });
+    }
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.intervalMs);
+  }
+  async stop() {
+    if (this.timer !== void 0) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  async tick() {
+    const traceId = crypto.randomUUID();
+    const context = {
+      traceId,
+      logger: createLogger3()
+    };
+    try {
+      await this.handler({}, context);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      context.logger.error("Schedule handler failed", {
+        cron: this.cron,
+        error: errorMessage
+      });
+    }
+  }
+};
+function createLogger3() {
+  return {
+    debug: (msg, data) => console.debug(JSON.stringify({ level: "debug", msg, ...data })),
+    info: (msg, data) => console.info(JSON.stringify({ level: "info", msg, ...data })),
+    warn: (msg, data) => console.warn(JSON.stringify({ level: "warn", msg, ...data })),
+    error: (msg, data) => console.error(JSON.stringify({ level: "error", msg, ...data }))
+  };
+}
+
+// src/triggers/queue.ts
+var QueueTriggerAdapter = class {
+  type = "queue";
+  queueName;
+  messageBus;
+  handler;
+  inputSchema;
+  subscription;
+  constructor(options) {
+    this.queueName = options.trigger.name;
+    this.messageBus = options.messageBus;
+    this.handler = options.handler;
+    this.inputSchema = options.inputSchema;
+  }
+  async start() {
+    this.subscription = await this.messageBus.subscribe(
+      this.queueName,
+      (message) => this.handleMessage(message)
+    );
+  }
+  async stop() {
+    if (this.subscription) {
+      await this.subscription.cancel();
+      this.subscription = void 0;
+    }
+  }
+  async handleMessage(message) {
+    let payload = message.payload;
+    if (this.inputSchema) {
+      const result = this.inputSchema.safeParse(payload);
+      if (!result.success) {
+        const logger = createLogger4();
+        logger.warn("Queue payload validation failed", {
+          queueName: this.queueName,
+          errors: result.error.issues
+        });
+        return;
+      }
+      payload = result.data;
+    }
+    const traceId = message.traceContext?.["traceId"] ?? crypto.randomUUID();
+    const context = {
+      traceId,
+      logger: createLogger4()
+    };
+    try {
+      await this.handler(payload, context);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      context.logger.error("Queue handler failed", {
+        queueName: this.queueName,
+        error: errorMessage
+      });
+    }
+  }
+};
+function createLogger4() {
+  return {
+    debug: (msg, data) => console.debug(JSON.stringify({ level: "debug", msg, ...data })),
+    info: (msg, data) => console.info(JSON.stringify({ level: "info", msg, ...data })),
+    warn: (msg, data) => console.warn(JSON.stringify({ level: "warn", msg, ...data })),
+    error: (msg, data) => console.error(JSON.stringify({ level: "error", msg, ...data }))
+  };
+}
+
+// src/observability/noop.ts
+var NOOP_SPAN = {
+  setAttribute: () => {
+  },
+  setError: () => {
+  },
+  end: () => {
+  }
+};
+var NoopObservabilityProvider = class {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  startSpan(name, attributes) {
+    return NOOP_SPAN;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  recordMetric(name, value, tags) {
+  }
+};
+var noopProvider = new NoopObservabilityProvider();
+
+// src/observability/otel.ts
+var OtelObservabilityProvider = class {
+  serviceName;
+  constructor(serviceName = "stackwright-service") {
+    this.serviceName = serviceName;
+  }
+  startSpan(name, attributes) {
+    const spanId = crypto.randomUUID().slice(0, 16);
+    const startTime = Date.now();
+    console.info(
+      JSON.stringify({
+        type: "span_start",
+        spanId,
+        name,
+        service: this.serviceName,
+        attributes,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    const spanAttributes = { ...attributes };
+    return {
+      setAttribute(key, value) {
+        spanAttributes[key] = value;
+      },
+      setError(error) {
+        spanAttributes["error"] = true;
+        spanAttributes["error.message"] = error.message;
+        console.error(
+          JSON.stringify({
+            type: "span_error",
+            spanId,
+            name,
+            error: error.message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      },
+      end() {
+        const duration = Date.now() - startTime;
+        console.info(
+          JSON.stringify({
+            type: "span_end",
+            spanId,
+            name,
+            duration,
+            attributes: spanAttributes,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+    };
+  }
+  recordMetric(name, value, tags) {
+    console.info(
+      JSON.stringify({
+        type: "metric",
+        name,
+        value,
+        tags,
+        service: this.serviceName,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+};
+
+// src/observability/factory.ts
+function createObservabilityProvider(options) {
+  const otelEnabled = process.env["OTEL_ENABLED"];
+  if (otelEnabled === "true" || otelEnabled === "1") {
+    return new OtelObservabilityProvider(options?.serviceName);
+  }
+  return noopProvider;
+}
+
+// src/observability/audit-noop.ts
+var NoopAuditProvider = class {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  record(_event) {
+  }
+  async flush() {
+  }
+};
+var noopAuditProvider = new NoopAuditProvider();
+
+// src/observability/audit-console.ts
+var ConsoleAuditProvider = class {
+  record(event) {
+    process.stderr.write(JSON.stringify(event) + "\n");
+  }
+  async flush() {
+  }
+};
+
+// src/observability/audit-factory.ts
+function createAuditProvider() {
+  const auditEnabled = process.env["STACKWRIGHT_AUDIT"];
+  if (auditEnabled === "true" || auditEnabled === "1") {
+    return new ConsoleAuditProvider();
+  }
+  return noopAuditProvider;
+}
+
+// src/observability/audit-hash.ts
+import { createHash } from "crypto";
+function auditHash(value) {
+  const serialized = JSON.stringify(value, (_key, val) => {
+    if (typeof val === "bigint") return val.toString();
+    if (val instanceof Error) return { message: val.message, name: val.name };
+    if (typeof val === "function") return "[function]";
+    if (typeof val === "symbol") return val.toString();
+    if (val === void 0) return null;
+    return val;
+  });
+  return createHash("sha256").update(serialized ?? "undefined").digest("hex").slice(0, 16);
+}
+
+// src/messaging/noop.ts
+var InMemoryMessageBusProvider = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  nextId = 0;
+  async publish(topic, message) {
+    const messageId = message.metadata?.messageId ?? `mem-${++this.nextId}`;
+    const topicHandlers = this.subscriptions.get(topic);
+    if (topicHandlers) {
+      const enrichedMessage = {
+        ...message,
+        metadata: {
+          ...message.metadata,
+          messageId,
+          timestamp: message.metadata?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      const handlers = Array.from(topicHandlers.values());
+      await Promise.all(handlers.map((handler) => handler(enrichedMessage)));
+    }
+    return { messageId, topic, success: true };
+  }
+  async subscribe(topic, handler) {
+    const id = `sub-${++this.nextId}`;
+    let topicHandlers = this.subscriptions.get(topic);
+    if (!topicHandlers) {
+      topicHandlers = /* @__PURE__ */ new Map();
+      this.subscriptions.set(topic, topicHandlers);
+    }
+    topicHandlers.set(id, handler);
+    const cancel = async () => {
+      await this.unsubscribe({ id, topic, cancel: async () => {
+      } });
+    };
+    return { id, topic, cancel };
+  }
+  async unsubscribe(subscription) {
+    const topicHandlers = this.subscriptions.get(subscription.topic);
+    if (topicHandlers) {
+      topicHandlers.delete(subscription.id);
+      if (topicHandlers.size === 0) {
+        this.subscriptions.delete(subscription.topic);
+      }
+    }
+  }
+  /** Helper for testing: get count of active subscriptions for a topic */
+  getSubscriptionCount(topic) {
+    return this.subscriptions.get(topic)?.size ?? 0;
+  }
+  /** Helper for testing: clear all subscriptions */
+  clear() {
+    this.subscriptions.clear();
+  }
+};
+var inMemoryBusProvider = new InMemoryMessageBusProvider();
+
+// src/messaging/index.ts
+init_sqs_sns();
+
+// src/messaging/factory.ts
+function createMessageBusProvider(options) {
+  const providerType = options?.provider ?? process.env["MESSAGE_BUS_PROVIDER"] ?? "memory";
+  switch (providerType) {
+    case "memory":
+      return inMemoryBusProvider;
+    case "sqs": {
+      const { SqsSnsMessageBusProvider: SqsSnsMessageBusProvider2 } = (init_sqs_sns(), __toCommonJS(sqs_sns_exports));
+      return new SqsSnsMessageBusProvider2(options?.config);
+    }
+    default:
+      console.warn(
+        `stackwright-services:messaging Unknown MESSAGE_BUS_PROVIDER "${providerType}", falling back to in-memory`
+      );
+      return inMemoryBusProvider;
+  }
+}
+
+// src/notifications/noop.ts
+var InMemoryNotificationProvider = class {
+  notifications = [];
+  nextId = 0;
+  async send(notification) {
+    const notificationId = `notif-${++this.nextId}`;
+    this.notifications.push({
+      ...notification,
+      notificationId,
+      metadata: {
+        ...notification.metadata,
+        timestamp: notification.metadata?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    return {
+      notificationId,
+      channel: notification.channel,
+      success: true
+    };
+  }
+  /** Helper for testing: get all sent notifications */
+  getSentNotifications() {
+    return [...this.notifications];
+  }
+  /** Helper for testing: get notifications filtered by channel */
+  getByChannel(channel) {
+    return this.notifications.filter((n) => n.channel === channel);
+  }
+  /** Helper for testing: get notifications filtered by recipient */
+  getByRecipient(recipient) {
+    return this.notifications.filter((n) => n.recipient === recipient);
+  }
+  /** Helper for testing: get count of sent notifications */
+  get sentCount() {
+    return this.notifications.length;
+  }
+  /** Helper for testing: clear all recorded notifications */
+  clear() {
+    this.notifications = [];
+    this.nextId = 0;
+  }
+};
+var inMemoryNotificationProvider = new InMemoryNotificationProvider();
+
+// src/notifications/factory.ts
+function createNotificationProvider(options) {
+  const providerType = options?.provider ?? process.env["NOTIFICATION_PROVIDER"] ?? "memory";
+  switch (providerType) {
+    case "memory":
+      return inMemoryNotificationProvider;
+    // Future: case 'sendgrid' -> SendGrid adapter
+    // Future: case 'twilio' -> Twilio/SNS adapter
+    // Future: case 'fcm' -> Firebase Cloud Messaging adapter
+    default:
+      console.warn(
+        `stackwright-services:notifications Unknown NOTIFICATION_PROVIDER "${providerType}", falling back to in-memory`
+      );
+      return inMemoryNotificationProvider;
+  }
+}
+
+// src/auth/noop.ts
+var NoopAuthProvider = class {
+  name = "noop";
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async validateToken(token) {
+    return { valid: false, error: "No auth provider configured" };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async extractClaims(token) {
+    throw new Error("No auth provider configured");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  checkRole(claims, role) {
+    return false;
+  }
+};
+var noopAuthProvider = new NoopAuthProvider();
+
+// src/auth/factory.ts
+function createAuthProvider(type) {
+  switch (type) {
+    case "oidc":
+      throw new Error(
+        "OIDC auth provider not yet implemented. Install @stackwright-pro/auth when available."
+      );
+    case "cac":
+      throw new Error(
+        "CAC/PKI auth provider not yet implemented. Install @stackwright-pro/auth when available."
+      );
+    case "noop":
+    default:
+      return noopAuthProvider;
+  }
+}
+
+// src/datasource/noop.ts
+var NoopDataSourceProvider = class {
+  name = "noop";
+  listSources() {
+    return [];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  execute(_source, _operation, _params) {
+    return Promise.reject(
+      new Error(
+        "No DataSourceProvider is configured. Install @stackwright-pro/openapi or @stackwright-pro/pulse and register an adapter, or set DATA_SOURCE_PROVIDER in your environment."
+      )
+    );
+  }
+};
+var noopDataSourceProvider = new NoopDataSourceProvider();
+
+// src/datasource/openapi-adapter.ts
+var LOG_PREFIX2 = "stackwright-services:datasource:openapi";
+var OpenApiDataSourceProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.sourcesMap = new Map(config.sources.map((s) => [s.id, s]));
+  }
+  name = "openapi";
+  sourcesMap;
+  listSources() {
+    return Array.from(this.sourcesMap.values()).map((s) => ({
+      id: s.id,
+      transport: "openapi",
+      operations: Object.keys(s.operations),
+      ...s.description !== void 0 && { description: s.description }
+    }));
+  }
+  async execute(source, operation, params) {
+    const registration = this.sourcesMap.get(source);
+    if (!registration) {
+      const knownSources = Array.from(this.sourcesMap.keys());
+      return Promise.reject(
+        new Error(
+          `${LOG_PREFIX2} Unknown source "${source}". ` + (knownSources.length > 0 ? `Known sources: ${knownSources.join(", ")}.` : "No sources are registered. Pass sources in OpenApiAdapterConfig.")
+        )
+      );
+    }
+    const handler = registration.operations[operation];
+    if (!handler) {
+      const knownOps = Object.keys(registration.operations);
+      return Promise.reject(
+        new Error(
+          `${LOG_PREFIX2} Unknown operation "${operation}" on source "${source}". ` + (knownOps.length > 0 ? `Known operations: ${knownOps.join(", ")}.` : "No operations are registered for this source.")
+        )
+      );
+    }
+    const data = await handler(params);
+    return { data };
+  }
+};
+function createOpenApiDataSourceProvider(config) {
+  return new OpenApiDataSourceProvider(config);
+}
+function listDataSources() {
+  return [];
+}
+
+// src/datasource/pulse-adapter.ts
+var LOG_PREFIX3 = "stackwright-services:datasource:pulse";
+var PulseDataSourceProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.sourcesMap = new Map(config.sources.map((s) => [s.id, s]));
+  }
+  name = "pulse";
+  sourcesMap;
+  listSources() {
+    return Array.from(this.sourcesMap.values()).map((s) => ({
+      id: s.id,
+      transport: "pulse",
+      operations: Object.keys(s.operations),
+      ...s.description !== void 0 && { description: s.description }
+    }));
+  }
+  async execute(source, operation, params) {
+    const registration = this.sourcesMap.get(source);
+    if (!registration) {
+      const knownSources = Array.from(this.sourcesMap.keys());
+      return Promise.reject(
+        new Error(
+          `${LOG_PREFIX3} Unknown source "${source}". ` + (knownSources.length > 0 ? `Known sources: ${knownSources.join(", ")}.` : "No sources are registered. Pass sources in PulseAdapterConfig.")
+        )
+      );
+    }
+    const handler = registration.operations[operation];
+    if (!handler) {
+      const knownOps = Object.keys(registration.operations);
+      return Promise.reject(
+        new Error(
+          `${LOG_PREFIX3} Unknown operation "${operation}" on source "${source}". ` + (knownOps.length > 0 ? `Known operations: ${knownOps.join(", ")}.` : "No operations are registered for this source.")
+        )
+      );
+    }
+    const data = await handler(params);
+    return { data };
+  }
+};
+function createPulseDataSourceProvider(config) {
+  return new PulseDataSourceProvider(config);
+}
+function listDataSources2() {
+  return [];
+}
+
+// src/datasource/factory.ts
+function createDataSourceProvider(options) {
+  const providerType = options?.provider ?? process.env["DATA_SOURCE_PROVIDER"] ?? _autoDiscover();
+  switch (providerType) {
+    case "noop":
+      return noopDataSourceProvider;
+    case "openapi": {
+      return createOpenApiDataSourceProvider(
+        options?.config ?? { sources: [] }
+      );
+    }
+    case "pulse": {
+      return createPulseDataSourceProvider(
+        options?.config ?? { sources: [] }
+      );
+    }
+    default:
+      if (providerType !== "noop") {
+        console.warn(
+          `stackwright-services:datasource Unknown DATA_SOURCE_PROVIDER "${providerType}", falling back to noop`
+        );
+      }
+      return noopDataSourceProvider;
+  }
+}
+function _autoDiscover() {
+  const candidates = [
+    // @stackwright-pro/openapi ships its own datasource-adapter entry point that
+    // auto-registers all generated clients — when that package is installed, 'openapi'
+    // is returned here. The local OpenApiDataSourceProvider requires explicit source
+    // registration and does NOT trigger auto-discovery.
+    { pkg: "@stackwright-pro/openapi/datasource-adapter", providerType: "openapi" },
+    // @stackwright-pro/pulse follows the same pattern for Pulse-backed data sources.
+    { pkg: "@stackwright-pro/pulse/datasource-adapter", providerType: "pulse" }
+  ];
+  for (const { pkg, providerType } of candidates) {
+    try {
+      __require.resolve(pkg);
+      return providerType;
+    } catch {
+    }
+  }
+  return "noop";
+}
+
+// src/datasource/scan.ts
+function scanDataSources() {
+  const sources = [];
+  const detectedProviders = [];
+  try {
+    __require.resolve("@stackwright-pro/openapi/datasource-adapter");
+    detectedProviders.push("@stackwright-pro/openapi");
+    try {
+      const mod = __require("@stackwright-pro/openapi/datasource-adapter");
+      if (typeof mod.listDataSources === "function") {
+        sources.push(...mod.listDataSources());
+      }
+    } catch (err) {
+      console.warn(
+        "stackwright-services:datasource Failed to enumerate @stackwright-pro/openapi sources:",
+        err
+      );
+    }
+  } catch {
+  }
+  try {
+    __require.resolve("@stackwright-pro/pulse/datasource-adapter");
+    detectedProviders.push("@stackwright-pro/pulse");
+    try {
+      const mod = __require("@stackwright-pro/pulse/datasource-adapter");
+      if (typeof mod.listDataSources === "function") {
+        sources.push(...mod.listDataSources());
+      }
+    } catch (err) {
+      console.warn(
+        "stackwright-services:datasource Failed to enumerate @stackwright-pro/pulse sources:",
+        err
+      );
+    }
+  } catch {
+  }
+  return { sources, detectedProviders };
+}
+
+// src/prebuild/register.ts
+import { CapabilityRegistry, registerAllCapabilities } from "@stackwright-services/capabilities";
+var PACKAGE_VERSION = "0.0.1";
+function enumerateTriggers() {
+  return [
+    {
+      type: "http",
+      description: "HTTP request/response trigger \u2014 becomes API Gateway route (Lambda) or Ingress (k8s)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          method: { type: "string", enum: ["GET", "POST", "PUT", "DELETE", "PATCH"] },
+          path: { type: "string", pattern: "^/" },
+          input_schema: { type: "string" }
+        },
+        required: ["method", "path"]
+      },
+      example: {
+        type: "http",
+        method: "POST",
+        path: "/api/patients/at-risk",
+        input_schema: "AtRiskRequest"
+      }
+    },
+    {
+      type: "event",
+      description: "Pub/sub event trigger \u2014 subscribes to a message bus topic",
+      inputSchema: {
+        type: "object",
+        properties: {
+          source: { type: "string", pattern: "^bus:" },
+          input_schema: { type: "string" }
+        },
+        required: ["source"]
+      },
+      example: {
+        type: "event",
+        source: "bus:equipment-status",
+        input_schema: "EquipmentStatusEvent"
+      }
+    },
+    {
+      type: "schedule",
+      description: "Cron-style scheduled trigger \u2014 periodic invocation",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cron: { type: "string" },
+          input_schema: { type: "string" }
+        },
+        required: ["cron"]
+      },
+      example: { type: "schedule", cron: "0 */6 * * *", input_schema: "ScheduledCheckInput" }
+    },
+    {
+      type: "queue",
+      description: "Durable point-to-point queue trigger \u2014 processes messages sequentially",
+      inputSchema: {
+        type: "object",
+        properties: {
+          source: { type: "string", pattern: "^queue:" },
+          batch_size: { type: "number", minimum: 1, maximum: 10 },
+          input_schema: { type: "string" }
+        },
+        required: ["source"]
+      },
+      example: {
+        type: "queue",
+        source: "queue:approvals",
+        batch_size: 1,
+        input_schema: "ApprovalMessage"
+      }
+    }
+  ];
+}
+function enumerateCapabilities() {
+  const registry = new CapabilityRegistry();
+  registerAllCapabilities(registry);
+  return registry.listAll().map((cap) => {
+    const descriptor = {
+      name: cap.definition.name,
+      kind: cap.definition.kind,
+      description: cap.definition.description,
+      inputSchema: cap.definition.inputSchema,
+      outputSchema: cap.definition.outputSchema
+    };
+    if (cap.definition.kind === "effect") {
+      descriptor.requiredPermissions = cap.definition.requiredPermissions;
+    }
+    return descriptor;
+  });
+}
+function enumerateDataSources() {
+  const scanResult = scanDataSources();
+  return scanResult.sources.map((source) => ({
+    id: source.id,
+    provider: source.transport,
+    operations: source.operations
+  }));
+}
+function registerServices() {
+  return {
+    pluginId: "@stackwright-services/runtime",
+    version: PACKAGE_VERSION,
+    triggers: enumerateTriggers(),
+    capabilities: enumerateCapabilities(),
+    dataSources: enumerateDataSources(),
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+export {
+  ConsoleAuditProvider,
+  EventTriggerAdapter,
+  InMemoryMessageBusProvider,
+  InMemoryNotificationProvider,
+  NoopAuditProvider,
+  NoopAuthProvider,
+  NoopDataSourceProvider,
+  NoopObservabilityProvider,
+  OpenApiDataSourceProvider,
+  OtelObservabilityProvider,
+  PulseDataSourceProvider,
+  QueueTriggerAdapter,
+  ScheduleTriggerAdapter,
+  SqsSnsMessageBusProvider,
+  auditHash,
+  createAuditProvider,
+  createAuthProvider,
+  createDataSourceProvider,
+  createHttpTrigger,
+  createMessageBusProvider,
+  createNotificationProvider,
+  createObservabilityProvider,
+  createOpenApiDataSourceProvider,
+  createPulseDataSourceProvider,
+  inMemoryBusProvider,
+  inMemoryNotificationProvider,
+  listDataSources as listOpenApiDataSources,
+  listDataSources2 as listPulseDataSources,
+  noopAuditProvider,
+  noopAuthProvider,
+  noopDataSourceProvider,
+  noopProvider,
+  registerServices,
+  scanDataSources
+};
+//# sourceMappingURL=index.mjs.map