@sockethub/schemas 3.0.0-alpha.11 → 3.0.0-alpha.13

package/dist/index.js

@@ -4,15 +4,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -4560,6 +4574,7 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
+  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -4572,10 +4587,18 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      if ($data) {
+        const { regExp } = it.opts.code;
+        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+        const valid = gen.let("valid");
+        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+        cxt.fail$data((0, codegen_1._)`!${valid}`);
+      } else {
+        const regExp = (0, code_1.usePattern)(cxt, schema);
+        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      }
     }
   };
   exports.default = def;
@@ -15735,19 +15758,70 @@ var require_ajv_formats_draft2019 = __commonJS((exports, module) => {
   };
 });
 
-// src/helpers/objects.ts
-var validObjectRefs = [];
-var validObjectDefs = {};
-var ObjectTypesSchema = {
-  credentials: {
-    required: ["type"],
-    additionalProperties: true,
-    properties: {
-      type: {
-        enum: ["credentials"]
+// src/context.ts
+var AS2_BASE_CONTEXT_URL = "https://www.w3.org/ns/activitystreams";
+var SOCKETHUB_BASE_CONTEXT_URL = "https://sockethub.org/ns/context/v1.jsonld";
+var PLATFORM_CONTEXT_PREFIX = "https://sockethub.org/ns/context/platform/";
+var ERROR_PLATFORM_ID = "error";
+var ERROR_PLATFORM_CONTEXT_URL = "https://sockethub.org/ns/context/platform/error/v1.jsonld";
+var INTERNAL_PLATFORM_ID = "sockethub:internal";
+var INTERNAL_PLATFORM_CONTEXT_URL = "https://sockethub.org/ns/context/platform/sockethub:internal/v1.jsonld";
+var platformContextToPlatformId = new Map;
+var platformContextToSchemaId = new Map;
+var platformContextToCredentialsSchemaId = new Map;
+function buildCanonicalContext(platform) {
+  const platformUrl = platform.startsWith("https://") ? platform : `${PLATFORM_CONTEXT_PREFIX}${platform}/v1.jsonld`;
+  return [AS2_BASE_CONTEXT_URL, SOCKETHUB_BASE_CONTEXT_URL, platformUrl];
+}
+function platformIdFromContext(context) {
+  if (!Array.isArray(context)) {
+    return;
+  }
+  for (const entry of context) {
+    if (typeof entry === "string" && entry.startsWith(PLATFORM_CONTEXT_PREFIX)) {
+      const rest = entry.slice(PLATFORM_CONTEXT_PREFIX.length);
+      const slashIdx = rest.indexOf("/");
+      if (slashIdx > 0) {
+        return rest.slice(0, slashIdx);
       }
     }
-  },
+  }
+  return;
+}
+function normalizeContextArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => typeof entry === "string");
+}
+function getContextArray(msg) {
+  return normalizeContextArray(msg["@context"]);
+}
+function registerPlatformContext(platformId, platformContextUrl, schemaId, credentialsSchemaId) {
+  platformContextToPlatformId.set(platformContextUrl, platformId);
+  platformContextToSchemaId.set(platformContextUrl, schemaId);
+  platformContextToCredentialsSchemaId.set(platformContextUrl, credentialsSchemaId);
+}
+function resolvePlatformContextUrl(msg) {
+  const contexts = getContextArray(msg);
+  const matches = contexts.filter((contextUrl) => platformContextToPlatformId.has(contextUrl));
+  if (matches.length !== 1) {
+    return null;
+  }
+  return matches[0];
+}
+function getPlatformIdByContextUrl(platformContextUrl) {
+  return platformContextToPlatformId.get(platformContextUrl);
+}
+function getSchemaIdByContextUrl(platformContextUrl) {
+  return platformContextToSchemaId.get(platformContextUrl);
+}
+function getCredentialsSchemaIdByContextUrl(platformContextUrl) {
+  return platformContextToCredentialsSchemaId.get(platformContextUrl);
+}
+
+// src/helpers/objects.ts
+var ObjectTypesSchema = {
   feed: {
     required: ["id", "type"],
     additionalProperties: true,
@@ -15773,37 +15847,22 @@ var ObjectTypesSchema = {
       }
     }
   },
-  message: {
-    required: ["type", "content"],
+  person: {
+    required: ["id", "type"],
     additionalProperties: true,
     properties: {
-      type: {
-        enum: ["message"]
-      },
       id: {
         type: "string"
       },
-      name: {
-        type: "string"
-      },
-      content: {
-        type: "string"
-      }
-    }
-  },
-  me: {
-    required: ["type", "content"],
-    additionalProperties: true,
-    properties: {
       type: {
-        enum: ["me"]
+        enum: ["person"]
       },
-      content: {
+      name: {
         type: "string"
       }
     }
   },
-  person: {
+  room: {
     required: ["id", "type"],
     additionalProperties: true,
     properties: {
@@ -15811,14 +15870,14 @@ var ObjectTypesSchema = {
         type: "string"
       },
       type: {
-        enum: ["person"]
+        enum: ["room"]
       },
       name: {
         type: "string"
       }
     }
   },
-  room: {
+  service: {
     required: ["id", "type"],
     additionalProperties: true,
     properties: {
@@ -15826,14 +15885,14 @@ var ObjectTypesSchema = {
         type: "string"
       },
       type: {
-        enum: ["room"]
+        enum: ["service"]
       },
       name: {
         type: "string"
       }
     }
   },
-  service: {
+  platform: {
     required: ["id", "type"],
     additionalProperties: true,
     properties: {
@@ -15841,7 +15900,7 @@ var ObjectTypesSchema = {
         type: "string"
       },
       type: {
-        enum: ["service"]
+        enum: ["platform"]
       },
       name: {
         type: "string"
@@ -15864,71 +15923,6 @@ var ObjectTypesSchema = {
       }
     }
   },
-  attendance: {
-    required: ["type"],
-    additionalProperties: false,
-    properties: {
-      type: {
-        enum: ["attendance"]
-      },
-      members: {
-        type: "array",
-        items: {
-          type: "string"
-        }
-      }
-    }
-  },
-  presence: {
-    required: ["type"],
-    additionalProperties: false,
-    properties: {
-      type: {
-        enum: ["presence"]
-      },
-      presence: {
-        enum: ["away", "chat", "dnd", "xa", "offline", "online"]
-      },
-      role: {
-        enum: ["owner", "member", "participant", "admin"]
-      },
-      content: {
-        type: "string"
-      }
-    }
-  },
-  relationship: {
-    required: ["type", "relationship"],
-    additionalProperties: false,
-    properties: {
-      type: {
-        enum: ["relationship"]
-      },
-      relationship: {
-        enum: ["role"]
-      },
-      subject: {
-        type: "object",
-        oneOf: [{ $ref: "#/definitions/type/presence" }]
-      },
-      object: {
-        type: "object",
-        oneOf: validObjectRefs
-      }
-    }
-  },
-  topic: {
-    required: ["type"],
-    additionalProperties: false,
-    properties: {
-      type: {
-        enum: ["topic"]
-      },
-      content: {
-        type: "string"
-      }
-    }
-  },
   address: {
     required: ["type"],
     additionalProperties: false,
@@ -15939,41 +15933,52 @@ var ObjectTypesSchema = {
     }
   }
 };
+var InternalObjectTypesList = ["platform", "heartbeat"];
 var ObjectTypesList = Object.keys(ObjectTypesSchema);
-for (const type of ObjectTypesList) {
-  if (type === "credentials") {
-    continue;
-  }
-  validObjectRefs.push({ $ref: `#/definitions/type/${type}` });
-  validObjectDefs[type] = ObjectTypesSchema[type];
-}
-
-// src/schemas/activity-object.ts
-var ActivityObjectSchema = {
-  $id: "https://sockethub.org/schemas/v/activity-object.json",
-  description: "Schema for Sockethub Activity Objects",
-  type: "object",
-  required: ["object"],
-  properties: {
-    object: {
-      type: "object",
-      oneOf: validObjectRefs
-    }
-  },
-  definitions: {
-    type: validObjectDefs
-  }
-};
+var ActorTypesList = [
+  "person",
+  "room",
+  "service",
+  "feed",
+  "website",
+  "platform"
+];
+var TargetTypesList = [
+  "person",
+  "room",
+  "service",
+  "feed",
+  "website",
+  "platform",
+  "address"
+];
+var validActorRefs = ActorTypesList.map((type) => ({
+  $ref: `#/definitions/type/${type}`
+}));
+var validTargetRefs = TargetTypesList.map((type) => ({
+  $ref: `#/definitions/type/${type}`
+}));
 
 // src/schemas/activity-stream.ts
-var validActorRefs = ActivityObjectSchema.properties.object.oneOf;
-var validTargetRefs = ActivityObjectSchema.properties.object.oneOf;
-var validObjectRefs2 = [];
-for (const type of ObjectTypesList) {
-  validObjectRefs2.push({ $ref: `#/definitions/type/${type}` });
-}
 var contextSchema = {
-  type: "string"
+  type: "array",
+  minItems: 3,
+  maxItems: 3,
+  items: {
+    type: "string"
+  },
+  allOf: [
+    {
+      contains: {
+        const: AS2_BASE_CONTEXT_URL
+      }
+    },
+    {
+      contains: {
+        const: SOCKETHUB_BASE_CONTEXT_URL
+      }
+    }
+  ]
 };
 var typeSchema = {
   type: "string"
@@ -15982,13 +15987,14 @@ var ActivityStreamSchema = {
   $id: "https://sockethub.org/schemas/v/activity-stream.json",
   description: "Schema for Sockethub Activity Streams",
   type: "object",
-  required: ["context", "type", "actor"],
+  required: ["@context", "type", "actor"],
+  additionalProperties: false,
   properties: {
+    "@context": contextSchema,
     id: {
       type: "string"
     },
     type: typeSchema,
-    context: contextSchema,
     actor: {
       type: "object",
       oneOf: validActorRefs
@@ -15998,8 +16004,7 @@ var ActivityStreamSchema = {
       oneOf: validTargetRefs
     },
     object: {
-      type: "object",
-      oneOf: validObjectRefs2
+      type: "object"
     },
     published: {
       type: "string",
@@ -16015,9 +16020,33 @@ var ActivityStreamSchema = {
 var PlatformSchema = {
   $id: "https://sockethub.org/schemas/v/platform.json",
   type: "object",
-  required: ["name", "version", "messages"],
+  required: [
+    "name",
+    "version",
+    "messages",
+    "contextUrl",
+    "contextVersion",
+    "schemaVersion"
+  ],
   additionalProperties: false,
   properties: {
+    contextUrl: {
+      title: "contextUrl",
+      type: "string",
+      format: "uri"
+    },
+    contextVersion: {
+      title: "contextVersion",
+      type: "string"
+    },
+    schemaVersion: {
+      title: "schemaVersion",
+      type: "string"
+    },
+    messageConstraints: {
+      title: "messageConstraints",
+      type: "object"
+    },
     credentials: {
       title: "credentials",
       type: "object"
@@ -16026,6 +16055,10 @@ var PlatformSchema = {
       title: "messages",
       type: "object"
     },
+    responses: {
+      title: "responses",
+      type: "object"
+    },
     name: {
       title: "name",
       type: "string"
@@ -16038,11 +16071,6 @@ var PlatformSchema = {
 };
 
 // src/schemas/sockethub-config.ts
-var connectConfigPlatforms = {
-  connectTimeoutMs: {
-    type: "number"
-  }
-};
 var SockethubConfigSchema = {
   $id: "https://sockethub.org/schemas/v/sockethub-config.json",
   description: "Sockethub Config Schema",
@@ -16057,6 +16085,10 @@ var SockethubConfigSchema = {
       type: "boolean",
       default: true
     },
+    info: {
+      type: "boolean",
+      default: false
+    },
     logging: {
       type: "object",
       additionalProperties: false,
@@ -16077,71 +16109,76 @@ var SockethubConfigSchema = {
         }
       }
     },
+    platforms: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      default: [
+        "@sockethub/platform-dummy",
+        "@sockethub/platform-feeds",
+        "@sockethub/platform-irc",
+        "@sockethub/platform-metadata",
+        "@sockethub/platform-xmpp"
+      ]
+    },
     packageConfig: {
       type: "object",
       properties: {
-        "@sockethub/activity-streams": {
+        "@sockethub/platform-dummy": {
           type: "object",
           additionalProperties: false,
           properties: {
-            specialObjs: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              default: ["credentials"]
-            },
-            failOnUnknownObjectProperties: {
-              type: "boolean",
-              default: true
-            }
+            greeting: { type: "string", default: "Hello" }
           }
         },
-        "@sockethub/platform-dummy": {
+        "@sockethub/platform-feeds": {
           type: "object",
           additionalProperties: false,
           properties: {
-            greeting: {
-              type: "string",
-              default: "Hello"
-            }
+            connectTimeoutMs: { type: "number" },
+            allowPrivateAddresses: { type: "boolean" },
+            concurrency: { type: "integer", minimum: 1 }
           }
         },
-        "@sockethub/platform-feeds": {
+        "@sockethub/platform-irc": {
           type: "object",
           additionalProperties: false,
           properties: {
-            ...connectConfigPlatforms
+            connectTimeoutMs: { type: "number" }
           }
         },
-        "@sockethub/platform-irc": {
+        "@sockethub/platform-xmpp": {
           type: "object",
           additionalProperties: false,
           properties: {
-            ...connectConfigPlatforms
+            connectTimeoutMs: { type: "number" }
           }
         },
-        "@sockethub/platform-xmpp": {
+        "@sockethub/platform-metadata": {
           type: "object",
           additionalProperties: false,
           properties: {
-            ...connectConfigPlatforms
+            allowPrivateAddresses: { type: "boolean" },
+            concurrency: { type: "integer", minimum: 1 }
           }
         }
       }
     },
-    platforms: {
-      type: "array",
-      items: {
-        type: "string"
-      },
-      default: [
-        "@sockethub/platform-dummy",
-        "@sockethub/platform-feeds",
-        "@sockethub/platform-irc",
-        "@sockethub/platform-metadata",
-        "@sockethub/platform-xmpp"
-      ]
+    credentialCheck: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        reconnectIpSource: {
+          type: "string",
+          enum: ["socket", "proxy"],
+          default: "socket"
+        },
+        proxyHeader: {
+          type: "string",
+          default: "x-forwarded-for"
+        }
+      }
     },
     public: {
       type: "object",
@@ -16180,6 +16217,22 @@ var SockethubConfigSchema = {
         blockDurationMs: {
           type: "number",
           default: 5000
+        },
+        maxConnectionsPerIp: {
+          type: "number",
+          minimum: 0,
+          default: 0
+        }
+      }
+    },
+    limits: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxPlatformInstances: {
+          type: "number",
+          minimum: 0,
+          default: 0
         }
       }
     },
@@ -16237,6 +16290,30 @@ var SockethubConfigSchema = {
         path: {
           type: "string",
           default: "/sockethub"
+        },
+        cors: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            origin: {
+              type: "string",
+              default: "*"
+            }
+          }
+        }
+      }
+    },
+    platformHeartbeat: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        intervalMs: {
+          type: "number",
+          default: 5000
+        },
+        timeoutMs: {
+          type: "number",
+          default: 15000
         }
       }
     }
@@ -16259,11 +16336,15 @@ function parseMsg(error) {
   return err;
 }
 function getTypeList(msg) {
-  let types = [];
-  types.push(msg?.type);
-  for (const prop in msg) {
-    if (msg[prop]?.type) {
-      types = [...types, ...getTypeList(msg[prop])];
+  const types = [];
+  if (msg?.type) {
+    types.push(msg.type);
+  }
+  const record = msg;
+  for (const prop in record) {
+    const value = record[prop];
+    if (value && typeof value === "object" && "type" in value) {
+      types.push(...getTypeList(value));
     }
   }
   return types;
@@ -16282,23 +16363,32 @@ function getPartsCount(error, types) {
   if (!errType) {
     return -1;
   }
-  if (!types[errType]) {
+  const typeList = types[errType];
+  if (!typeList) {
     return -1;
   }
-  if (!types[errType].includes(schemaType)) {
+  if (!schemaType || !typeList.includes(schemaType)) {
     return -1;
   }
   const parts = error.instancePath.split("/");
   return parts.length;
 }
 function getTypes(msg) {
+  if (!Array.isArray(msg["@context"])) {
+    return {
+      actor: [],
+      target: [],
+      object: getTypeList(msg)
+    };
+  }
+  const stream = msg;
   return {
-    actor: getTypeList(msg.actor),
-    target: getTypeList(msg.target),
-    object: getTypeList(msg.context ? msg.object : msg)
+    actor: getTypeList(stream.actor),
+    target: getTypeList(stream.target),
+    object: stream.object ? getTypeList(stream.object) : []
   };
 }
-function getErrorMessage(msg, errors) {
+function getErrorMessage(msg, errors, options) {
   const types = getTypes(msg);
   let deepest_entry = 0;
   let highest_depth = -1;
@@ -16309,12 +16399,23 @@ function getErrorMessage(msg, errors) {
       deepest_entry = i;
     }
   }
-  return highest_depth >= 0 ? parseMsg(errors[deepest_entry]) : composeFinalError(errors[errors.length - 1]);
+  return highest_depth >= 0 ? parseMsg(errors[deepest_entry]) : composeFinalError(errors[errors.length - 1], options);
+}
+function filterTypeList(types, options) {
+  if (!options?.excludeTypes || options.excludeTypes.length === 0) {
+    return types;
+  }
+  const exclude = new Set(options.excludeTypes);
+  return types.filter((type) => !exclude.has(type));
 }
-function composeFinalError(error) {
+function composeFinalError(error, options) {
   let msg;
   if (error.keyword === "oneOf") {
-    msg = `${error.instancePath}: ${error.message}: ` + `${ObjectTypesList.join(", ")}`;
+    const instanceRoot = error.instancePath.split("/")[1];
+    const pathScopedTypes = instanceRoot === "actor" ? ActorTypesList : instanceRoot === "target" ? TargetTypesList : ObjectTypesList;
+    const filteredTypes = filterTypeList(pathScopedTypes, options);
+    const typesList = filteredTypes.length > 0 ? filteredTypes : pathScopedTypes;
+    msg = `${error.instancePath}: ${error.message}: ` + `${typesList.join(", ")}`;
   } else {
     msg = `${error.instancePath ? error.instancePath : "activity stream"}: ${error.message}`;
   }
@@ -16330,69 +16431,211 @@ import_ajv_formats.default(ajv);
 import_ajv_formats_draft2019.default(ajv);
 var schemaURL = "https://sockethub.org/schemas/v0";
 var schemas = {};
+var validationErrorOptions = {};
+var systemContextsRegistered = false;
 schemas[`${schemaURL}/activity-stream`] = ActivityStreamSchema;
-schemas[`${schemaURL}/activity-object`] = ActivityObjectSchema;
 for (const uri in schemas) {
   ajv.addSchema(schemas[uri], uri);
 }
-function handleValidation(schemaRef, msg, isObject = false) {
+function registerSystemContext(platformId, contextUrl) {
+  registerPlatformContext(platformId, contextUrl, `${schemaURL}/context/${platformId}/messages`, `${schemaURL}/context/${platformId}/credentials`);
+  const messageSchemaRef = `${schemaURL}/context/${platformId}/messages`;
+  if (!ajv.getSchema(messageSchemaRef)) {
+    ajv.addSchema({}, messageSchemaRef);
+  }
+  const credentialsSchemaRef = `${schemaURL}/context/${platformId}/credentials`;
+  if (!ajv.getSchema(credentialsSchemaRef)) {
+    ajv.addSchema({}, credentialsSchemaRef);
+  }
+}
+function registerSystemPlatformContexts() {
+  if (systemContextsRegistered) {
+    return;
+  }
+  registerSystemContext(ERROR_PLATFORM_ID, ERROR_PLATFORM_CONTEXT_URL);
+  registerSystemContext(INTERNAL_PLATFORM_ID, INTERNAL_PLATFORM_CONTEXT_URL);
+  systemContextsRegistered = true;
+}
+registerSystemPlatformContexts();
+function handleValidation(schemaRef, msg) {
   const validator = ajv.getSchema(schemaRef);
-  let result;
-  if (isObject) {
-    result = validator({ object: msg });
-  } else {
-    result = validator(msg);
+  if (!validator) {
+    return `schema ${schemaRef} not found`;
   }
+  const result = validator(msg);
   if (!result) {
-    let errorMessage = getErrorMessage(msg, validator.errors);
-    if (msg.context) {
-      errorMessage = `[${msg.context}] ${errorMessage}`;
+    let errorMessage = getErrorMessage(msg, validator.errors, validationErrorOptions);
+    if (Array.isArray(msg["@context"])) {
+      const platformContextUrl = resolvePlatformContextUrl(msg);
+      if (platformContextUrl) {
+        const platformId = getPlatformIdByContextUrl(platformContextUrl);
+        if (platformId) {
+          errorMessage = `[${platformId}] ${errorMessage}`;
+        }
+      }
     }
     return errorMessage;
   }
   return "";
 }
-function validateActivityObject(msg) {
-  return handleValidation(`${schemaURL}/activity-object`, msg, true);
+function setValidationErrorOptions(options) {
+  validationErrorOptions = { ...validationErrorOptions, ...options };
+}
+var sockethubConfigValidator;
+function validateSockethubConfig(config) {
+  if (!sockethubConfigValidator) {
+    sockethubConfigValidator = ajv.compile(SockethubConfigSchema);
+  }
+  if (sockethubConfigValidator(config)) {
+    return "";
+  }
+  return ajv.errorsText(sockethubConfigValidator.errors, {
+    dataVar: "config"
+  });
 }
 function validateActivityStream(msg) {
-  return handleValidation(`${schemaURL}/activity-stream`, msg);
+  const streamValidationError = handleValidation(`${schemaURL}/activity-stream`, msg);
+  if (streamValidationError) {
+    return streamValidationError;
+  }
+  const platformContextUrl = resolvePlatformContextUrl(msg);
+  if (!platformContextUrl) {
+    return "activity streams must have exactly one registered platform context URL in @context";
+  }
+  const schemaId = getSchemaIdByContextUrl(platformContextUrl);
+  if (!schemaId) {
+    return `platform context URL ${platformContextUrl} does not have a registered message schema`;
+  }
+  return handleValidation(schemaId, msg);
+}
+function validateActivityStreamResponse(msg) {
+  const platformContextUrl = resolvePlatformContextUrl(msg);
+  if (!platformContextUrl) {
+    return "";
+  }
+  const platformId = getPlatformIdByContextUrl(platformContextUrl);
+  if (!platformId) {
+    return "";
+  }
+  const responsesSchemaId = `${schemaURL}/context/${platformId}/responses`;
+  if (!ajv.getSchema(responsesSchemaId)) {
+    return "";
+  }
+  return handleValidation(responsesSchemaId, msg);
 }
 function validateCredentials(msg) {
-  if (!msg.context) {
-    return "credential activity streams must have a context set";
+  if (!Array.isArray(msg["@context"])) {
+    return "credential activity streams must have an @context set";
   }
   if (msg.type !== "credentials") {
     return "credential activity streams must have credentials set as type";
   }
-  return handleValidation(`${schemaURL}/context/${msg.context}/credentials`, msg);
+  const streamValidationError = handleValidation(`${schemaURL}/activity-stream`, msg);
+  if (streamValidationError) {
+    return streamValidationError;
+  }
+  const platformContextUrl = resolvePlatformContextUrl(msg);
+  if (!platformContextUrl) {
+    return "credential activity streams must have exactly one registered platform context URL in @context";
+  }
+  const credentialsSchemaId = getCredentialsSchemaIdByContextUrl(platformContextUrl);
+  if (!credentialsSchemaId) {
+    return `platform context URL ${platformContextUrl} does not have a registered credentials schema`;
+  }
+  return handleValidation(credentialsSchemaId, msg);
 }
 function validatePlatformSchema(schema) {
   const validate = ajv.compile(PlatformSchema);
   const err = validate(schema);
   if (!err) {
-    return `platform schema failed to validate: ${validate.errors[0].instancePath} ${validate.errors[0].message}`;
+    const validationError = validate.errors[0];
+    let message = `${validationError.instancePath} ${validationError.message}`;
+    if (validationError.keyword === "additionalProperties") {
+      message += `: ${validationError.params.additionalProperty}`;
+    }
+    return `platform schema failed to validate: ${message}`;
   }
   return "";
 }
 function addPlatformSchema(schema, platform_type) {
-  ajv.addSchema(schema, `${schemaURL}/context/${platform_type}`);
+  const schemaRef = `${schemaURL}/context/${platform_type}`;
+  if (!ajv.getSchema(schemaRef)) {
+    ajv.addSchema(schema, schemaRef);
+  }
 }
 function getPlatformSchema(platform_type) {
   return ajv.getSchema(`${schemaURL}/context/${platform_type}`);
 }
+function addPlatformContext(platformId, platformContextUrl) {
+  registerPlatformContext(platformId, platformContextUrl, `${schemaURL}/context/${platformId}/messages`, `${schemaURL}/context/${platformId}/credentials`);
+}
+function resolvePlatformId(msg) {
+  const platformContextUrl = resolvePlatformContextUrl(msg);
+  if (!platformContextUrl) {
+    return null;
+  }
+  return getPlatformIdByContextUrl(platformContextUrl) ?? null;
+}
+
+// src/activity-stream-helper.ts
+var stringRefKeys = {
+  actor: "id",
+  target: "id",
+  object: "content"
+};
+function normalizeStringRef(value, primaryKey) {
+  if (typeof value === "string") {
+    return { [primaryKey]: value };
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => {
+      if (typeof entry === "string") {
+        return { id: entry };
+      }
+      return entry;
+    });
+  }
+  return value;
+}
+function normalizeActivityStream(meta) {
+  const stream = {
+    ...meta
+  };
+  for (const key of Object.keys(stringRefKeys)) {
+    if (key in stream) {
+      stream[key] = normalizeStringRef(stream[key], stringRefKeys[key]);
+    }
+  }
+  return stream;
+}
 export {
+  validateSockethubConfig,
   validatePlatformSchema,
   validateCredentials,
+  validateActivityStreamResponse,
   validateActivityStream,
-  validateActivityObject,
+  setValidationErrorOptions,
+  resolvePlatformId,
+  registerSystemPlatformContexts,
+  platformIdFromContext,
+  normalizeActivityStream,
   getPlatformSchema,
+  buildCanonicalContext,
   addPlatformSchema,
+  addPlatformContext,
   SockethubConfigSchema,
+  SOCKETHUB_BASE_CONTEXT_URL,
   PlatformSchema,
+  PLATFORM_CONTEXT_PREFIX,
+  ObjectTypesSchema,
   ObjectTypesList,
+  InternalObjectTypesList,
+  INTERNAL_PLATFORM_ID,
+  INTERNAL_PLATFORM_CONTEXT_URL,
+  ERROR_PLATFORM_ID,
+  ERROR_PLATFORM_CONTEXT_URL,
   ActivityStreamSchema,
-  ActivityObjectSchema
+  AS2_BASE_CONTEXT_URL
 };
 
-//# debugId=6F40F71261F1E85264756E2164756E21
+//# debugId=E0C024B0EB3D053564756E2164756E21