@contractspec/lib.contracts-spec 2.0.0

package/dist/node/capabilities/meeting-recorder.js

@@ -0,0 +1,154 @@
+import { createRequire } from "node:module";
+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;
+};
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/capabilities/meeting-recorder.ts
+var OWNERS = ["platform.integrations"];
+var TAGS = ["meeting-recorder", "transcripts", "integrations"];
+var meetingRecorderMeetingsReadCapability = {
+  meta: {
+    key: "meeting-recorder.meetings.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Meetings (Read)",
+    description: "Provides read-only access to recorded meetings and their metadata.",
+    domain: "integrations",
+    owners: [...OWNERS],
+    tags: [...TAGS, "meetings"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.meetings.list",
+      version: "1.0.0",
+      description: "List meetings available from the recorder provider."
+    },
+    {
+      surface: "operation",
+      key: "meeting-recorder.meetings.get",
+      version: "1.0.0",
+      description: "Fetch detailed metadata for a specific meeting."
+    }
+  ]
+};
+var meetingRecorderTranscriptsReadCapability = {
+  meta: {
+    key: "meeting-recorder.transcripts.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Transcripts (Read)",
+    description: "Enables retrieval of transcripts for recorded meetings from external providers.",
+    domain: "integrations",
+    owners: [...OWNERS],
+    tags: [...TAGS, "transcripts"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.transcripts.get",
+      version: "1.0.0",
+      description: "Fetch the transcript for a specific meeting recording."
+    },
+    {
+      surface: "operation",
+      key: "meeting-recorder.transcripts.sync",
+      version: "1.0.0",
+      description: "Trigger a transcript sync from the recorder provider."
+    }
+  ]
+};
+var meetingRecorderWebhooksCapability = {
+  meta: {
+    key: "meeting-recorder.webhooks",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Webhooks",
+    description: "Allows processing of webhook events for meeting transcript readiness.",
+    domain: "integrations",
+    owners: [...OWNERS],
+    tags: [...TAGS, "webhooks"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.webhooks.ingest",
+      version: "1.0.0",
+      description: "Ingest and verify meeting recorder webhook payloads."
+    }
+  ]
+};
+function registerMeetingRecorderCapabilities(registry) {
+  return registry.register(meetingRecorderMeetingsReadCapability).register(meetingRecorderTranscriptsReadCapability).register(meetingRecorderWebhooksCapability);
+}
+export {
+  registerMeetingRecorderCapabilities,
+  meetingRecorderWebhooksCapability,
+  meetingRecorderTranscriptsReadCapability,
+  meetingRecorderMeetingsReadCapability
+};

package/dist/node/capabilities/openbanking.js

@@ -0,0 +1,166 @@
+import { createRequire } from "node:module";
+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;
+};
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/capabilities/openbanking.ts
+var OWNERS = ["platform.finance"];
+var TAGS = ["open-banking", "finance"];
+var openBankingAccountsReadCapability = {
+  meta: {
+    key: "openbanking.accounts.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Accounts (Read)",
+    description: "Provides read-only access to linked bank accounts, including account summaries and metadata.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.accounts.list",
+      version: "1.0.0",
+      description: "List bank accounts linked to a Powens open banking connection."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.accounts.get",
+      version: "1.0.0",
+      description: "Retrieve the canonical bank account record for a specific account."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.accounts.sync",
+      version: "1.0.0",
+      description: "Trigger a refresh of bank account metadata from the open banking provider."
+    }
+  ]
+};
+var openBankingTransactionsReadCapability = {
+  meta: {
+    key: "openbanking.transactions.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Transactions (Read)",
+    description: "Enables retrieval of transaction history for linked bank accounts via open banking providers.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS, "transactions"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.transactions.list",
+      version: "1.0.0",
+      description: "List transactions for a given bank account with optional date filtering."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.transactions.sync",
+      version: "1.0.0",
+      description: "Synchronise transactions from the open banking provider into the canonical ledger."
+    }
+  ]
+};
+var openBankingBalancesReadCapability = {
+  meta: {
+    key: "openbanking.balances.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Balances (Read)",
+    description: "Allows querying of current and available balances for linked bank accounts via open banking providers.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS, "balances"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.balances.get",
+      version: "1.0.0",
+      description: "Retrieve the latest known balances for a specified bank account."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.balances.refresh",
+      version: "1.0.0",
+      description: "Force a balance refresh from the open banking provider."
+    }
+  ]
+};
+function registerOpenBankingCapabilities(registry) {
+  return registry.register(openBankingAccountsReadCapability).register(openBankingTransactionsReadCapability).register(openBankingBalancesReadCapability);
+}
+export {
+  registerOpenBankingCapabilities,
+  openBankingTransactionsReadCapability,
+  openBankingBalancesReadCapability,
+  openBankingAccountsReadCapability
+};

package/dist/node/capabilities/validation.js

@@ -0,0 +1,185 @@
+import { createRequire } from "node:module";
+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;
+};
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/capabilities/validation.ts
+function validateCapabilityConsistency(deps) {
+  const errors = [];
+  const warnings = [];
+  for (const capability of deps.capabilities.list()) {
+    const capKey = `${capability.meta.key}.v${capability.meta.version}`;
+    for (const surface of capability.provides ?? []) {
+      const exists = checkSurfaceExists(deps, surface.surface, surface.key);
+      if (!exists) {
+        errors.push({
+          type: "missing_surface_spec",
+          message: `Capability "${capKey}" provides ${surface.surface} "${surface.key}" but spec not found`,
+          capabilityKey: capKey,
+          surface: surface.surface,
+          specKey: surface.key
+        });
+      }
+    }
+  }
+  if (deps.operations) {
+    for (const op of deps.operations.list()) {
+      if (op.capability) {
+        const capSpec = deps.capabilities.get(op.capability.key, op.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Operation "${op.meta.key}" references capability "${op.capability.key}.v${op.capability.version}" but capability not found`,
+            specKey: op.meta.key,
+            capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+            surface: "operation"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "operation" && p.key === op.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Operation "${op.meta.key}" claims capability "${op.capability.key}.v${op.capability.version}" but not in capability's provides`,
+              specKey: op.meta.key,
+              capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+              surface: "operation"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (deps.events) {
+    for (const event of deps.events.list()) {
+      if (event.capability) {
+        const capSpec = deps.capabilities.get(event.capability.key, event.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Event "${event.meta.key}" references capability "${event.capability.key}.v${event.capability.version}" but capability not found`,
+            specKey: event.meta.key,
+            capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+            surface: "event"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "event" && p.key === event.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Event "${event.meta.key}" claims capability "${event.capability.key}.v${event.capability.version}" but not in capability's provides`,
+              specKey: event.meta.key,
+              capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+              surface: "event"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (deps.presentations) {
+    for (const pres of deps.presentations.list()) {
+      if (pres.capability) {
+        const capSpec = deps.capabilities.get(pres.capability.key, pres.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Presentation "${pres.meta.key}" references capability "${pres.capability.key}.v${pres.capability.version}" but capability not found`,
+            specKey: pres.meta.key,
+            capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+            surface: "presentation"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "presentation" && p.key === pres.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Presentation "${pres.meta.key}" claims capability "${pres.capability.key}.v${pres.capability.version}" but not in capability's provides`,
+              specKey: pres.meta.key,
+              capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+              surface: "presentation"
+            });
+          }
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function checkSurfaceExists(deps, surface, key) {
+  switch (surface) {
+    case "operation":
+      return deps.operations?.has(key) ?? true;
+    case "event":
+      return deps.events?.has(key) ?? true;
+    case "presentation":
+      return deps.presentations?.has(key) ?? true;
+    case "workflow":
+    case "resource":
+      return true;
+    default:
+      return true;
+  }
+}
+function findOrphanSpecs(deps) {
+  const result = {
+    operations: [],
+    events: [],
+    presentations: []
+  };
+  if (deps.operations) {
+    for (const op of deps.operations.list()) {
+      if (!op.capability) {
+        result.operations.push(op.meta.key);
+      }
+    }
+  }
+  if (deps.events) {
+    for (const event of deps.events.list()) {
+      if (!event.capability) {
+        result.events.push(event.meta.key);
+      }
+    }
+  }
+  if (deps.presentations) {
+    for (const pres of deps.presentations.list()) {
+      if (!pres.capability) {
+        result.presentations.push(pres.meta.key);
+      }
+    }
+  }
+  return result;
+}
+export {
+  validateCapabilityConsistency,
+  findOrphanSpecs
+};

package/dist/node/contract-registry/index.js

@@ -0,0 +1,129 @@
+import { createRequire } from "node:module";
+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;
+};
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/contract-registry/schemas.ts
+import z from "zod";
+var ContractRegistryItemTypeValues = [
+  "contractspec:operation",
+  "contractspec:event",
+  "contractspec:presentation",
+  "contractspec:form",
+  "contractspec:feature",
+  "contractspec:workflow",
+  "contractspec:template",
+  "contractspec:integration",
+  "contractspec:data-view",
+  "contractspec:migration",
+  "contractspec:telemetry",
+  "contractspec:experiment",
+  "contractspec:app-config",
+  "contractspec:knowledge"
+];
+var ContractRegistryItemTypeSchema = z.enum(ContractRegistryItemTypeValues);
+var ContractRegistryFileSchema = z.object({
+  path: z.string().min(1),
+  type: z.string().min(1),
+  content: z.string().optional()
+});
+var ContractRegistryItemSchema = z.object({
+  key: z.string().min(1),
+  type: ContractRegistryItemTypeSchema,
+  version: z.string(),
+  title: z.string().min(1),
+  description: z.string().min(1),
+  meta: z.object({
+    stability: z.enum([
+      StabilityEnum.Idea,
+      StabilityEnum.InCreation,
+      StabilityEnum.Experimental,
+      StabilityEnum.Beta,
+      StabilityEnum.Stable,
+      StabilityEnum.Deprecated
+    ]),
+    owners: z.array(z.string().min(1)).default([]),
+    tags: z.array(z.string().min(1)).default([])
+  }),
+  dependencies: z.array(z.string().min(1)).optional(),
+  registryDependencies: z.array(z.string().min(1)).optional(),
+  files: z.array(ContractRegistryFileSchema).min(1),
+  schema: z.object({
+    input: z.unknown().optional(),
+    output: z.unknown().optional()
+  }).optional()
+});
+var ContractRegistryManifestSchema = z.object({
+  $schema: z.string().min(1).optional(),
+  name: z.string().min(1),
+  homepage: z.string().min(1).optional(),
+  items: z.array(ContractRegistryItemSchema)
+});
+export {
+  ContractRegistryManifestSchema,
+  ContractRegistryItemTypeSchema,
+  ContractRegistryItemSchema,
+  ContractRegistryFileSchema
+};