@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/integrations/openbanking/contracts/accounts.js

@@ -1,236 +1,974 @@
-import { defineCommand, defineQuery } from "../../../operations/operation.js";
-import "../../../operations/index.js";
-import { BankAccountRecord } from "../models.js";
-import { OPENBANKING_TELEMETRY_EVENTS } from "../telemetry.js";
-import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
-
-//#region src/integrations/openbanking/contracts/accounts.ts
-const OpenBankingListAccountsInput = new SchemaModel({
-	name: "OpenBankingListAccountsInput",
-	description: "Parameters for listing bank accounts through the open banking provider.",
-	fields: {
-		tenantId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		userId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		connectionId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: true
-		},
-		includeBalances: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		},
-		institutionId: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		cursor: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		pageSize: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: true
-		}
-	}
-});
-const OpenBankingListAccountsOutput = new SchemaModel({
-	name: "OpenBankingListAccountsOutput",
-	description: "Paginated list of bank accounts available to the tenant and user.",
-	fields: {
-		accounts: {
-			type: BankAccountRecord,
-			isOptional: false,
-			isArray: true
-		},
-		nextCursor: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isOptional: true
-		},
-		hasMore: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		}
-	}
-});
-const OpenBankingGetAccountInput = new SchemaModel({
-	name: "OpenBankingGetAccountInput",
-	description: "Parameters for retrieving a specific bank account.",
-	fields: {
-		tenantId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		accountId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		includeBalances: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		},
-		includeLatestTransactions: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		}
-	}
-});
-const OpenBankingSyncAccountsInput = new SchemaModel({
-	name: "OpenBankingSyncAccountsInput",
-	description: "Command payload to trigger an account synchronisation against the open banking provider.",
-	fields: {
-		tenantId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		userId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: true
-		},
-		connectionId: {
-			type: ScalarTypeEnum.ID(),
-			isOptional: false
-		},
-		accountIds: {
-			type: ScalarTypeEnum.ID(),
-			isArray: true,
-			isOptional: true
-		},
-		forceFullRefresh: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		},
-		triggerWorkflows: {
-			type: ScalarTypeEnum.Boolean(),
-			isOptional: true
-		}
-	}
-});
-const OpenBankingSyncAccountsOutput = new SchemaModel({
-	name: "OpenBankingSyncAccountsOutput",
-	description: "Result of a bank account synchronisation run.",
-	fields: {
-		synced: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		failed: {
-			type: ScalarTypeEnum.Int_unsecure(),
-			isOptional: false
-		},
-		errors: {
-			type: ScalarTypeEnum.String_unsecure(),
-			isArray: true,
-			isOptional: true
-		},
-		nextSyncSuggestedAt: {
-			type: ScalarTypeEnum.DateTime(),
-			isOptional: true
-		}
-	}
-});
-const OpenBankingListAccounts = defineQuery({
-	meta: {
-		key: "openbanking.accounts.list",
-		version: "1.0.0",
-		description: "List bank accounts available to a tenant/user via Powens Open Banking.",
-		goal: "Provide downstream workflows with the set of accounts accessible via the configured open banking connection.",
-		context: "Used by Pocket Family Office dashboards and sync workflows to enumerate bank accounts prior to syncing balances or transactions.",
-		owners: ["@platform.finance"],
-		tags: [
-			"open-banking",
-			"powens",
-			"accounts"
-		],
-		stability: "experimental"
-	},
-	io: {
-		input: OpenBankingListAccountsInput,
-		output: OpenBankingListAccountsOutput
-	},
-	policy: { auth: "user" }
-});
-const OpenBankingGetAccount = defineQuery({
-	meta: {
-		key: "openbanking.accounts.get",
-		version: "1.0.0",
-		description: "Retrieve the canonical bank account record for the given account identifier.",
-		goal: "Allow user-facing experiences and automations to display up-to-date account metadata.",
-		context: "Invoked by UI surfaces and workflow automation steps that require detailed metadata for a specific bank account.",
-		owners: ["@platform.finance"],
-		tags: [
-			"open-banking",
-			"powens",
-			"accounts"
-		],
-		stability: "experimental"
-	},
-	io: {
-		input: OpenBankingGetAccountInput,
-		output: BankAccountRecord
-	},
-	policy: { auth: "user" }
-});
-const OpenBankingSyncAccounts = defineCommand({
-	meta: {
-		key: "openbanking.accounts.sync",
-		version: "1.0.0",
-		description: "Initiate a synchronisation run to refresh bank account metadata from Powens.",
-		goal: "Keep canonical bank account records aligned with the external open banking provider.",
-		context: "Triggered by scheduled workflows or manual operator actions to reconcile account metadata prior to transaction/balance syncs.",
-		owners: ["@platform.finance"],
-		tags: [
-			"open-banking",
-			"powens",
-			"accounts"
-		],
-		stability: "experimental"
-	},
-	io: {
-		input: OpenBankingSyncAccountsInput,
-		output: OpenBankingSyncAccountsOutput
-	},
-	policy: { auth: "admin" },
-	telemetry: {
-		success: {
-			event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSynced },
-			properties: ({ input, output }) => {
-				const payload = input;
-				const result = output;
-				return {
-					tenantId: payload?.tenantId,
-					connectionId: payload?.connectionId,
-					synced: result?.synced,
-					failed: result?.failed
-				};
-			}
-		},
-		failure: {
-			event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSyncFailed },
-			properties: ({ input, error }) => {
-				const payload = input;
-				return {
-					tenantId: payload?.tenantId,
-					connectionId: payload?.connectionId,
-					error: error instanceof Error ? error.message : String(error ?? "unknown")
-				};
-			}
-		}
-	}
-});
-const openBankingAccountContracts = {
-	OpenBankingListAccounts,
-	OpenBankingGetAccount,
-	OpenBankingSyncAccounts
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
 };
-function registerOpenBankingAccountContracts(registry) {
-	return registry.register(OpenBankingListAccounts).register(OpenBankingGetAccount).register(OpenBankingSyncAccounts);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/registry-utils.ts
+var exports_registry_utils = {};
+__export(exports_registry_utils, {
+  groupByToArray: () => groupByToArray,
+  groupByMultiple: () => groupByMultiple,
+  groupBy: () => groupBy,
+  getUniqueTags: () => getUniqueTags,
+  getUniqueOwners: () => getUniqueOwners,
+  getUniqueDomains: () => getUniqueDomains,
+  filterBy: () => filterBy,
+  GroupingStrategies: () => GroupingStrategies
+});
+function filterBy(items, filter) {
+  return items.filter((item) => {
+    if (filter.tags?.length) {
+      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
+      if (!hasMatchingTag)
+        return false;
+    }
+    if (filter.owners?.length) {
+      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
+      if (!hasMatchingOwner)
+        return false;
+    }
+    if (filter.stability?.length) {
+      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
+        return false;
+      }
+    }
+    if (filter.domain) {
+      const itemDomain = GroupingStrategies.byDomain(item);
+      if (itemDomain !== filter.domain)
+        return false;
+    }
+    if (filter.keyPattern) {
+      const name = item.meta.key ?? item.meta.key ?? "";
+      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      if (!regex.test(name))
+        return false;
+    }
+    return true;
+  });
+}
+function groupBy(items, keyFn) {
+  const groups = new Map;
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+function groupByToArray(items, keyFn) {
+  const map = groupBy(items, keyFn);
+  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
+}
+function groupByMultiple(items, keysFn) {
+  const groups = new Map;
+  for (const item of items) {
+    const keys = keysFn(item);
+    for (const key of keys) {
+      const existing = groups.get(key);
+      if (existing) {
+        existing.push(item);
+      } else {
+        groups.set(key, [item]);
+      }
+    }
+  }
+  return groups;
+}
+function getUniqueTags(items) {
+  const tags = new Set;
+  for (const item of items) {
+    for (const tag of item.meta.tags ?? []) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
+function getUniqueOwners(items) {
+  const owners = new Set;
+  for (const item of items) {
+    for (const owner of item.meta.owners ?? []) {
+      owners.add(owner);
+    }
+  }
+  return Array.from(owners).sort();
+}
+function getUniqueDomains(items) {
+  const domains = new Set;
+  for (const item of items) {
+    domains.add(GroupingStrategies.byDomain(item));
+  }
+  return Array.from(domains).sort();
+}
+var GroupingStrategies;
+var init_registry_utils = __esm(() => {
+  GroupingStrategies = {
+    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
+    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
+    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
+    byDomain: (item) => {
+      const name = item.meta.key ?? item.meta.key ?? "";
+      return name.split(".")[0] ?? "default";
+    },
+    byStability: (item) => item.meta.stability ?? "stable",
+    byUrlPath: (level) => (item) => {
+      if (!item.path)
+        return "root";
+      const segments = item.path.split("/").filter(Boolean);
+      return segments.slice(0, level).join("/") || "root";
+    }
+  };
+});
+
+// src/ownership.ts
+var StabilityEnum = {
+  Idea: "idea",
+  InCreation: "in_creation",
+  Experimental: "experimental",
+  Beta: "beta",
+  Stable: "stable",
+  Deprecated: "deprecated"
+};
+var OwnersEnum = {
+  PlatformCore: "platform.core",
+  PlatformSigil: "platform.sigil",
+  PlatformMarketplace: "platform.marketplace",
+  PlatformMessaging: "platform.messaging",
+  PlatformContent: "platform.content",
+  PlatformFeatureFlags: "platform.featureflags",
+  PlatformFinance: "platform.finance"
+};
+var Owners = OwnersEnum;
+var TagsEnum = {
+  Spots: "spots",
+  Collectivity: "collectivity",
+  Marketplace: "marketplace",
+  Sellers: "sellers",
+  Auth: "auth",
+  Login: "login",
+  Signup: "signup",
+  Guide: "guide",
+  Docs: "docs",
+  I18n: "i18n",
+  Incident: "incident",
+  Automation: "automation",
+  Hygiene: "hygiene"
+};
+var Tags = TagsEnum;
+
+// src/operations/operation.ts
+var isEmitDeclRef = (e) => ("ref" in e);
+var defineCommand = (spec) => ({
+  ...spec,
+  meta: { ...spec.meta, kind: "command" },
+  policy: {
+    ...spec.policy,
+    idempotent: spec.policy?.["policy"]?.idempotent ?? false
+  }
+});
+var defineQuery = (spec) => ({
+  ...spec,
+  meta: { ...spec.meta, kind: "query" },
+  policy: { ...spec.policy, idempotent: true }
+});
+
+// src/registry.ts
+init_registry_utils();
+import { compareVersions } from "compare-versions";
+var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
+
+class SpecContractRegistry {
+  contractType;
+  items = new Map;
+  constructor(contractType, items) {
+    this.contractType = contractType;
+    if (items) {
+      items.forEach((p) => this.register(p));
+    }
+  }
+  register(p) {
+    const key = keyOfSpecContract(p);
+    if (this.items.has(key))
+      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
+    this.items.set(key, p);
+    return this;
+  }
+  count() {
+    return this.items.size;
+  }
+  list() {
+    return [...this.items.values()];
+  }
+  get(key, version) {
+    if (version != null)
+      return this.items.get(`${key}.v${version}`);
+    let candidate;
+    for (const [k, p] of this.items.entries()) {
+      if (!k.startsWith(`${key}.v`))
+        continue;
+      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
+        candidate = p;
+      }
+    }
+    return candidate;
+  }
+  has(key, version) {
+    return !!this.get(key, version);
+  }
+  filter(criteria) {
+    return filterBy(this.list(), criteria);
+  }
+  listByTag(tag) {
+    return this.list().filter((p) => p.meta.tags?.includes(tag));
+  }
+  listByOwner(owner) {
+    return this.list().filter((p) => p.meta.owners?.includes(owner));
+  }
+  groupBy(keyFn) {
+    return groupBy(this.list(), keyFn);
+  }
+  getUniqueTags() {
+    return getUniqueTags(this.list());
+  }
+}
+
+// src/events.ts
+function defineEvent(e) {
+  return e;
+}
+var eventKey = (key, version) => `${key}.v${version}`;
+
+class EventRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("event", items);
+  }
+}
+
+// src/operations/registry.ts
+function opKey(key, version) {
+  return `${key}.v${version}`;
+}
+
+class OperationSpecRegistry extends SpecContractRegistry {
+  handlers = new Map;
+  constructor(items) {
+    super("operation", items);
+  }
+  bind(spec, handler) {
+    const key = opKey(spec.meta.key, spec.meta.version);
+    if (!this.items.has(key))
+      throw new Error(`Cannot bind; spec not found: ${key}`);
+    if (this.handlers.has(key))
+      throw new Error(`Handler already bound for ${key}`);
+    this.handlers.set(key, handler);
+    return this;
+  }
+  getHandler(key, version) {
+    const spec = this.get(key, version);
+    if (!spec)
+      return;
+    return this.handlers.get(opKey(spec.meta.key, spec.meta.version));
+  }
+  listBound() {
+    const out = [];
+    for (const [k, spec] of this.items.entries()) {
+      const h = this.handlers.get(k);
+      if (h)
+        out.push({ spec, handler: h });
+    }
+    return out;
+  }
+  async execute(key, version, rawInput, ctx) {
+    const baseSpec = this.get(key, version);
+    if (!baseSpec)
+      throw new Error(`Spec not found for ${key}${version ? `.v${version}` : ""}`);
+    const spec = await ctx.specVariantResolver?.resolve({
+      name: baseSpec.meta.key,
+      version: baseSpec.meta.version,
+      kind: baseSpec.meta.kind
+    }, ctx) ?? baseSpec;
+    let handlerKey = opKey(spec.meta.key, spec.meta.version);
+    let handler = this.handlers.get(handlerKey);
+    if (!handler) {
+      const fallbackKey = opKey(baseSpec.meta.key, baseSpec.meta.version);
+      handler = this.handlers.get(fallbackKey);
+      handlerKey = fallbackKey;
+    }
+    if (!handler)
+      throw new Error(`No handler bound for ${handlerKey}`);
+    const parsedInput = spec.io.input?.getZod().parse(rawInput);
+    if (ctx.decide) {
+      const [service, command] = spec.meta.key.split(".");
+      if (!service || !command)
+        throw new Error(`Invalid spec name: ${spec.meta.key}`);
+      const decision = await ctx.decide({
+        service,
+        command,
+        version: spec.meta.version,
+        actor: ctx.actor ?? "anonymous",
+        channel: ctx.channel,
+        roles: ctx.roles,
+        organizationId: ctx.organizationId,
+        userId: ctx.userId,
+        flags: []
+      });
+      if (decision.effect === "deny") {
+        throw new Error(`PolicyDenied: ${spec.meta.key}.v${spec.meta.version}`);
+      }
+      if (decision.rateLimit && ctx.rateLimit) {
+        const key2 = decision.rateLimit.key ?? "default";
+        const rpm = decision.rateLimit.rpm ?? 60;
+        await ctx.rateLimit(key2, 1, rpm);
+      }
+    }
+    const allowedEvents = new Map;
+    if (spec.sideEffects?.emits) {
+      for (const e of spec.sideEffects.emits) {
+        if (isEmitDeclRef(e)) {
+          const eventSpec = ctx.eventSpecResolver?.get(e.ref.key, e.ref.version);
+          if (eventSpec) {
+            allowedEvents.set(`${e.ref.key}.v${e.ref.version}`, eventSpec.payload);
+          }
+        } else {
+          allowedEvents.set(`${e.key}.v${e.version}`, e.payload);
+        }
+      }
+    }
+    const emitGuard = async (eventName, eventVersion, payload) => {
+      const key2 = eventKey(eventName, eventVersion);
+      const schema = allowedEvents.get(key2);
+      if (!schema)
+        throw new Error(`UndeclaredEvent: ${key2} not allowed by ${opKey(spec.meta.key, spec.meta.version)}`);
+      const parsed = schema.getZod().parse(payload);
+      await ctx.eventPublisher?.({
+        key: eventName,
+        version: eventVersion,
+        payload: parsed,
+        traceId: ctx.traceId
+      });
+    };
+    if (ctx.appConfig) {
+      if (!ctx.branding) {
+        ctx.branding = ctx.appConfig.branding;
+      }
+      if (!ctx.translation) {
+        ctx.translation = { config: ctx.appConfig.translation };
+      } else if (!ctx.translation.config) {
+        ctx.translation = {
+          ...ctx.translation,
+          config: ctx.appConfig.translation
+        };
+      }
+    }
+    const telemetryContext = ctx.telemetry;
+    const trackTelemetry = async (trigger, details) => {
+      if (!telemetryContext || !trigger?.event)
+        return;
+      try {
+        const props = trigger.properties?.(details) ?? {};
+        await telemetryContext.track(trigger.event.key, trigger.event.version ?? "1.0.0", props, {
+          tenantId: ctx.organizationId ?? undefined,
+          organizationId: ctx.organizationId,
+          userId: ctx.userId,
+          actor: ctx.actor,
+          channel: ctx.channel,
+          metadata: ctx.traceId ? { traceId: ctx.traceId } : undefined
+        });
+      } catch (_error) {}
+    };
+    let result;
+    try {
+      result = await handler(parsedInput, {
+        ...ctx,
+        __emitGuard__: emitGuard
+      });
+    } catch (error) {
+      if (spec.telemetry?.failure) {
+        await trackTelemetry(spec.telemetry.failure, {
+          input: parsedInput ?? rawInput,
+          error
+        });
+      }
+      throw error;
+    }
+    if (spec.telemetry?.success) {
+      await trackTelemetry(spec.telemetry.success, {
+        input: parsedInput ?? rawInput,
+        output: result
+      });
+    }
+    const outputModel = spec.io.output;
+    if (outputModel?.getZod) {
+      const parsedOutput = outputModel.getZod().parse(result);
+      return parsedOutput;
+    }
+    return result;
+  }
+}
+
+// src/operations/report/getContractVerificationStatus.ts
+import {
+  ScalarTypeEnum,
+  SchemaModel,
+  ZodSchemaType
+} from "@contractspec/lib.schema";
+import * as z from "zod";
+var REPORT_DOMAIN = "report";
+var REPORT_OWNERS = ["platform.core"];
+var REPORT_TAGS = ["report", "drift", "verification"];
+var REPORT_STABILITY = StabilityEnum.Experimental;
+var ContractVerificationStatusModel = new SchemaModel({
+  name: "ContractVerificationStatus",
+  fields: {
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    lastVerifiedSha: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    lastVerifiedDate: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    surfaces: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false,
+      isArray: true
+    },
+    driftMismatches: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: false
+    }
+  }
+});
+var GetContractVerificationStatusInput = new SchemaModel({
+  name: "GetContractVerificationStatusInput",
+  fields: {
+    projectPath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    baseline: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var GetContractVerificationStatusOutput = new ZodSchemaType(z.object({
+  contracts: z.object({
+    name: z.string(),
+    lastVerifiedSha: z.string().optional(),
+    lastVerifiedDate: z.string().optional(),
+    surfaces: z.string().array(),
+    driftMismatches: z.int()
+  }).array()
+}), {
+  name: "GetContractVerificationStatusOutput"
+});
+var GetContractVerificationStatusQuery = defineQuery({
+  meta: {
+    key: "report.getContractVerificationStatus",
+    title: "Get Contract Verification Status",
+    version: "1.0.0",
+    description: "Retrieves per-contract verification status for the impact report.",
+    goal: "Enable stakeholders to see contract health at a glance.",
+    context: "Part of the impact report domain. Reads from drift check outputs and verified.json to provide a consolidated view of each contract's drift debt and surface coverage.",
+    domain: REPORT_DOMAIN,
+    owners: REPORT_OWNERS,
+    tags: REPORT_TAGS,
+    stability: REPORT_STABILITY
+  },
+  io: {
+    input: GetContractVerificationStatusInput,
+    output: GetContractVerificationStatusOutput,
+    errors: {
+      PROJECT_NOT_FOUND: {
+        description: "Project path does not exist.",
+        http: 404,
+        when: "The provided projectPath does not resolve to a valid directory."
+      }
+    }
+  },
+  policy: {
+    auth: "anonymous",
+    pii: []
+  }
+});
+
+// src/install.ts
+function makeEmit(_spec, ctx) {
+  return {
+    ref: async (ev, payload) => {
+      await ctx.__emitGuard__?.(ev.meta.key, ev.meta.version, payload);
+    },
+    key: async (key, version, payload) => {
+      await ctx.__emitGuard__?.(key, version, payload);
+    },
+    object: async (evt) => {
+      await ctx.__emitGuard__?.(evt.key, evt.version, evt.payload);
+    }
+  };
+}
+function installOp(reg, spec, handler) {
+  return reg.register(spec).bind(spec, handler);
+}
+function op(spec, handler) {
+  return {
+    spec,
+    handler,
+    install: (reg) => installOp(reg, spec, handler)
+  };
+}
+
+// src/data-views/spec.ts
+function defineDataView(spec) {
+  return spec;
 }
 
-//#endregion
-export { OpenBankingGetAccount, OpenBankingListAccounts, OpenBankingSyncAccounts, openBankingAccountContracts, registerOpenBankingAccountContracts };
+// src/data-views/report/contractVerificationTable.ts
+var ContractVerificationTableDataView = defineDataView({
+  meta: {
+    key: "report.contractVerificationTable",
+    title: "Contract Verification Table",
+    version: "1.0.0",
+    description: "Table view of per-contract verification status for the impact report.",
+    domain: "report",
+    owners: ["platform.core"],
+    tags: ["report", "data-view", "verification"],
+    stability: StabilityEnum.Experimental,
+    entity: "contract-verification"
+  },
+  source: {
+    primary: {
+      key: GetContractVerificationStatusQuery.meta.key,
+      version: GetContractVerificationStatusQuery.meta.version
+    }
+  },
+  view: {
+    kind: "table",
+    fields: [
+      {
+        key: "name",
+        label: "Contract / Endpoint / Event",
+        dataPath: "name"
+      },
+      {
+        key: "timeSinceVerified",
+        label: "Time since verified",
+        dataPath: "lastVerifiedDate"
+      },
+      {
+        key: "driftMismatches",
+        label: "Drift debt",
+        dataPath: "driftMismatches",
+        format: "number",
+        sortable: true
+      },
+      {
+        key: "surfaces",
+        label: "Surfaces covered",
+        dataPath: "surfaces",
+        format: "badge"
+      },
+      {
+        key: "lastVerifiedSha",
+        label: "Last verified commit",
+        dataPath: "lastVerifiedSha",
+        width: "sm"
+      }
+    ],
+    primaryField: "name",
+    secondaryFields: ["driftMismatches", "timeSinceVerified"],
+    columns: [
+      { field: "name", width: "lg" },
+      { field: "lastVerifiedSha", width: "sm" },
+      { field: "timeSinceVerified", width: "sm" },
+      { field: "surfaces", width: "md" },
+      { field: "driftMismatches", width: "xs", align: "right" }
+    ]
+  },
+  policy: {
+    flags: [],
+    pii: []
+  }
+});
+
+// src/operations/report/index.ts
+var getContractVerificationStatusHandler = async (input, _ctx) => {
+  try {
+    const cmdProcess = Bun.spawn(["contractspec", "impl", "status", "--format", "json", "--all"], {
+      cwd: input.projectPath
+    });
+    const cmdStdout = await cmdProcess.stdout;
+    const output = await Bun.readableStreamToText(cmdStdout);
+    if (!output) {
+      return { contracts: [] };
+    }
+    const cliOutput = JSON.parse(output);
+    const contracts = [];
+    for (const spec of cliOutput.results || []) {
+      const contract = {
+        name: spec.specKey,
+        lastVerifiedSha: spec.specHash,
+        lastVerifiedDate: spec.specHash ? new Date().toISOString() : undefined,
+        surfaces: spec.implementations.filter((impl) => impl.exists).map((impl) => impl.type),
+        driftMismatches: spec.implementations.filter((impl) => !impl.exists).length
+      };
+      contracts.push(contract);
+    }
+    return { contracts };
+  } catch (error) {
+    console.error("Failed to get contract verification status:", error);
+    return { contracts: [] };
+  }
+};
+function registerReportContracts(registry) {
+  installOp(registry, GetContractVerificationStatusQuery, getContractVerificationStatusHandler);
+  return registry;
+}
+// src/integrations/openbanking/models.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+var BankAccountRecord = new SchemaModel2({
+  name: "BankAccountRecord",
+  description: "Canonical representation of a bank account synced from an open banking provider.",
+  fields: {
+    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    institutionId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    institutionName: {
+      type: ScalarTypeEnum2.NonEmptyString(),
+      isOptional: false
+    },
+    institutionLogoUrl: { type: ScalarTypeEnum2.URL(), isOptional: true },
+    iban: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    bic: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    accountType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
+    displayName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    accountNumberMasked: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    productCode: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    balance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
+    availableBalance: {
+      type: ScalarTypeEnum2.Float_unsecure(),
+      isOptional: true
+    },
+    lastSyncedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
+  }
+});
+var BankTransactionRecord = new SchemaModel2({
+  name: "BankTransactionRecord",
+  description: "Canonical transaction entry mapped from Powens into the open banking ledger.",
+  fields: {
+    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    amount: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
+    date: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    bookingDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    valueDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    counterpartyName: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    counterpartyAccount: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    merchantCategoryCode: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    rawCategory: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    standardizedCategory: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    transactionType: {
+      type: ScalarTypeEnum2.NonEmptyString(),
+      isOptional: false
+    },
+    status: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    runningBalance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var AccountBalanceRecord = new SchemaModel2({
+  name: "AccountBalanceRecord",
+  description: "Canonical balance snapshot computed from Powens balance payloads.",
+  fields: {
+    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    balanceType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
+    currentBalance: {
+      type: ScalarTypeEnum2.Float_unsecure(),
+      isOptional: false
+    },
+    availableBalance: {
+      type: ScalarTypeEnum2.Float_unsecure(),
+      isOptional: true
+    },
+    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
+    lastUpdatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
+    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
+  }
+});
+
+// src/integrations/openbanking/telemetry.ts
+var OPENBANKING_PII_FIELDS = [
+  "iban",
+  "bic",
+  "accountNumberMasked",
+  "accountNumber",
+  "counterpartyName",
+  "counterpartyAccount",
+  "description",
+  "merchantName",
+  "merchantCategoryCode",
+  "reference"
+];
+var OPENBANKING_TELEMETRY_EVENTS = {
+  accountsSynced: "openbanking.accounts.synced",
+  accountsSyncFailed: "openbanking.accounts.sync_failed",
+  transactionsSynced: "openbanking.transactions.synced",
+  transactionsSyncFailed: "openbanking.transactions.sync_failed",
+  balancesRefreshed: "openbanking.balances.refreshed",
+  balancesRefreshFailed: "openbanking.balances.refresh_failed",
+  overviewGenerated: "openbanking.overview.generated"
+};
+function redactOpenBankingTelemetryPayload(payload) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (OPENBANKING_PII_FIELDS.includes(key)) {
+      redacted[key] = maskValue(value);
+    } else if (Array.isArray(value)) {
+      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactOpenBankingTelemetryPayload(item) : item);
+    } else if (typeof value === "object" && value !== null) {
+      redacted[key] = redactOpenBankingTelemetryPayload(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function maskValue(value) {
+  if (value == null)
+    return "";
+  const str = String(value);
+  if (str.length <= 4)
+    return "*".repeat(str.length);
+  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
+}
+
+// src/integrations/openbanking/contracts/accounts.ts
+import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
+var OpenBankingListAccountsInput = new SchemaModel3({
+  name: "OpenBankingListAccountsInput",
+  description: "Parameters for listing bank accounts through the open banking provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
+    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    institutionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    cursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    pageSize: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingListAccountsOutput = new SchemaModel3({
+  name: "OpenBankingListAccountsOutput",
+  description: "Paginated list of bank accounts available to the tenant and user.",
+  fields: {
+    accounts: {
+      type: BankAccountRecord,
+      isOptional: false,
+      isArray: true
+    },
+    nextCursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingGetAccountInput = new SchemaModel3({
+  name: "OpenBankingGetAccountInput",
+  description: "Parameters for retrieving a specific bank account.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    includeLatestTransactions: {
+      type: ScalarTypeEnum3.Boolean(),
+      isOptional: true
+    }
+  }
+});
+var OpenBankingSyncAccountsInput = new SchemaModel3({
+  name: "OpenBankingSyncAccountsInput",
+  description: "Command payload to trigger an account synchronisation against the open banking provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum3.ID(), isOptional: true },
+    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    accountIds: {
+      type: ScalarTypeEnum3.ID(),
+      isArray: true,
+      isOptional: true
+    },
+    forceFullRefresh: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    triggerWorkflows: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingSyncAccountsOutput = new SchemaModel3({
+  name: "OpenBankingSyncAccountsOutput",
+  description: "Result of a bank account synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    errors: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    nextSyncSuggestedAt: {
+      type: ScalarTypeEnum3.DateTime(),
+      isOptional: true
+    }
+  }
+});
+var OpenBankingListAccounts = defineQuery({
+  meta: {
+    key: "openbanking.accounts.list",
+    version: "1.0.0",
+    description: "List bank accounts available to a tenant/user via Powens Open Banking.",
+    goal: "Provide downstream workflows with the set of accounts accessible via the configured open banking connection.",
+    context: "Used by Pocket Family Office dashboards and sync workflows to enumerate bank accounts prior to syncing balances or transactions.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingListAccountsInput,
+    output: OpenBankingListAccountsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingGetAccount = defineQuery({
+  meta: {
+    key: "openbanking.accounts.get",
+    version: "1.0.0",
+    description: "Retrieve the canonical bank account record for the given account identifier.",
+    goal: "Allow user-facing experiences and automations to display up-to-date account metadata.",
+    context: "Invoked by UI surfaces and workflow automation steps that require detailed metadata for a specific bank account.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingGetAccountInput,
+    output: BankAccountRecord
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingSyncAccounts = defineCommand({
+  meta: {
+    key: "openbanking.accounts.sync",
+    version: "1.0.0",
+    description: "Initiate a synchronisation run to refresh bank account metadata from Powens.",
+    goal: "Keep canonical bank account records aligned with the external open banking provider.",
+    context: "Triggered by scheduled workflows or manual operator actions to reconcile account metadata prior to transaction/balance syncs.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingSyncAccountsInput,
+    output: OpenBankingSyncAccountsOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSynced },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          connectionId: payload?.connectionId,
+          synced: result?.synced,
+          failed: result?.failed
+        };
+      }
+    },
+    failure: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSyncFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          connectionId: payload?.connectionId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var openBankingAccountContracts = {
+  OpenBankingListAccounts,
+  OpenBankingGetAccount,
+  OpenBankingSyncAccounts
+};
+function registerOpenBankingAccountContracts(registry2) {
+  return registry2.register(OpenBankingListAccounts).register(OpenBankingGetAccount).register(OpenBankingSyncAccounts);
+}
+export {
+  registerOpenBankingAccountContracts,
+  openBankingAccountContracts,
+  OpenBankingSyncAccounts,
+  OpenBankingListAccounts,
+  OpenBankingGetAccount
+};