@polytric/openws-spec 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1110 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "../node_modules/.pnpm/rfdc@1.4.1/node_modules/rfdc/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = rfdc;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc(opts) {
+      opts = opts || {};
+      if (opts.circles) return rfdcCircles(opts);
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      const refs = [];
+      const refsNew = [];
+      const constructorHandlers = /* @__PURE__ */ new Map();
+      constructorHandlers.set(Date, (o) => new Date(o));
+      constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+      constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+      if (opts.constructorHandlers) {
+        for (const handler2 of opts.constructorHandlers) {
+          constructorHandlers.set(handler2[0], handler2[1]);
+        }
+      }
+      let handler = null;
+      return opts.proto ? cloneProto : clone;
+      function cloneArray(a, fn) {
+        const keys = Object.keys(a);
+        const a2 = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          const cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            const index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, clone);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, clone);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false) continue;
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, clone);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null) return o;
+        if (Array.isArray(o)) return cloneArray(o, cloneProto);
+        if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+          return handler(o, cloneProto);
+        }
+        const o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (const k in o) {
+          const cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, cloneProto);
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            const i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
+// ../node_modules/.pnpm/@pocketgems+schema@0.1.3/node_modules/@pocketgems/schema/src/schema.js
+var require_schema = __commonJS({
+  "../node_modules/.pnpm/@pocketgems+schema@0.1.3/node_modules/@pocketgems/schema/src/schema.js"(exports2, module2) {
+    "use strict";
+    var assert = require("assert");
+    var ajv;
+    var deepcopy = require_rfdc()();
+    var ValidationError = class extends Error {
+      /**
+       * @param {string} name a user-provided name describing the schema
+       * @param {*} badValue the value which did not validate
+       * @param {Object} errors how badValue failed to conform to the schema
+       * @param {Object} expectedSchema The JSON schema used in schema validation
+       */
+      constructor(name, badValue, errors, expectedSchema) {
+        super(`Validation Error: ${name}`);
+        this.badValue = badValue;
+        this.validationErrors = errors;
+        this.expectedSchema = expectedSchema;
+        if (["localhost", "webpack"].includes(process.env.NODE_ENV)) {
+          console.error(JSON.stringify(errors, null, 2));
+        }
+      }
+    };
+    var INT32_MAX = Math.pow(2, 31) - 1;
+    var INT32_MIN = -Math.pow(2, 31);
+    var TIMESTAMP_MIN = "2000-01-01T00:00:00Z";
+    var TIMESTAMP_MAX = "9999-01-01T00:00:00Z";
+    var EPOCH_IN_MILLISECONDS_MIN = new Date(TIMESTAMP_MIN).getTime();
+    var EPOCH_IN_MILLISECONDS_MAX = new Date(TIMESTAMP_MAX).getTime();
+    var EPOCH_IN_SECONDS_MIN = EPOCH_IN_MILLISECONDS_MIN / 1e3;
+    var EPOCH_IN_SECONDS_MAX = EPOCH_IN_MILLISECONDS_MAX / 1e3;
+    var INT64_MAX = Math.pow(2, 62);
+    var INT64_MIN = -Math.pow(2, 62);
+    var BaseSchema = class {
+      /**
+       * The json schema type
+       */
+      static JSON_SCHEMA_TYPE;
+      /**
+       * The max* property name.
+       */
+      static MAX_PROP_NAME;
+      /**
+       * The min* property name.
+       */
+      static MIN_PROP_NAME;
+      /**
+       * Constructs a schema object
+       */
+      constructor() {
+        this.isTodeaSchema = true;
+        this.isFluentSchema = true;
+        this.__properties = {};
+        this.__isLocked = false;
+        this.__isOptional = false;
+        this.__setProp("type", this.constructor.JSON_SCHEMA_TYPE);
+      }
+      /**
+       * Locks a Todea Schema object from modifications.
+       */
+      lock() {
+        this.__isLocked = true;
+        return this;
+      }
+      /**
+       * Sets a value in __properties. Throws if object is locked (unless the
+       * property is allowed to be overridden), or property with
+       * the same name already exists and override is not allowed.
+       * @param {String} name Name of the property
+       * @param {*} val The value for the property
+       * @param {Object} [options={}]
+       * @param {Boolean} [options.allowOverride=false] If true property override
+       *   is allowed.
+       */
+      __setProp(name, val, { allowOverride = false } = {}) {
+        assert.ok(
+          !this.__isLocked || allowOverride,
+          "Schema is locked. Call copy then further modify the schema"
+        );
+        assert.ok(
+          allowOverride || !Object.prototype.hasOwnProperty.call(this.__properties, name),
+          `Property ${name} is already set.`
+        );
+        const shouldCopy = this.__isLocked || allowOverride && Object.prototype.hasOwnProperty.call(this.__properties, name);
+        const ret = shouldCopy ? this.copy() : this;
+        ret.__properties[name] = val;
+        if (this.__isLocked) {
+          ret.lock();
+        }
+        return ret;
+      }
+      /**
+       * @param {String} name Name of a property
+       * @return The value associated with name.
+       */
+      getProp(name) {
+        return this.__properties[name];
+      }
+      /**
+       * If property with name does not exist, the default value is set.
+       * @param {String} name
+       * @param {*} defaultValue
+       * @return The value associated with name.
+       */
+      __setDefaultProp(name, defaultValue) {
+        if (!Object.prototype.hasOwnProperty.call(this.__properties, name)) {
+          this.__setProp(name, defaultValue);
+        }
+        return this.getProp(name);
+      }
+      /**
+       * Sets a title.
+       * @param {String} t The title of the schema.
+       */
+      title(t) {
+        assert.ok(typeof t === "string", "Title must be a string.");
+        return this.__setProp("title", t, { allowOverride: true });
+      }
+      /**
+       * Sets a description.
+       * @param {String|Array<String>} t The description of the schema. If an array
+       *   of strings are passed in, they will be joined by a space to form the
+       *   description.
+       */
+      desc(d) {
+        assert.ok(typeof d === "string", "Description must be a string.");
+        d = d.trim().replace(/\n/g, " ");
+        return this.__setProp("description", d, { allowOverride: true });
+      }
+      /**
+       * Sets a default value for schema.
+       *
+       * According to JsonSchema, default value is just metadata and does not
+       * serve any validation purpose with in JsonSchema. External tools may
+       * choose to use this value to setup defaults, and implementations of
+       * JsonSchema validator may choose to validate the type of default values,
+       * but it's not required. Since when the default is used to populate the
+       * json, there will be something downstream that validates the json and
+       * catches issues, we omit schema validation for simplicity.
+       *
+       * @param {*} d The default value.
+       */
+      default(d) {
+        assert(d !== void 0, "Default value must be defined");
+        Object.freeze(d);
+        return this.__setProp("default", d);
+      }
+      getDefault() {
+        return this.properties().default;
+      }
+      hasDefault() {
+        return Object.prototype.hasOwnProperty.call(this.properties(), "default");
+      }
+      /**
+       * Marks a schema as optional. Schemas are required by default.
+       */
+      optional() {
+        assert(!this.__isLocked, "Schema is locked.");
+        this.__isOptional = true;
+        return this;
+      }
+      /**
+       * Convenient getter indicates if the schema is required / not optional.
+       * See {@link optional}.
+       */
+      get required() {
+        return !this.__isOptional;
+      }
+      /**
+       * Sets schemas readOnly property.
+       * @param {Boolean} [r=true] If the schema value should be readOnly.
+       */
+      readOnly(r = true) {
+        return this.__setProp("readOnly", r);
+      }
+      /**
+       * Updates schemas examples.
+       * @param {Array<String|Array<String>>} es A list of examples. Each example
+       *   may be a string, or a list of strings. In case of a list of strings, the
+       *   strings will be joined by a space character and used as one example.
+       */
+      examples(es) {
+        assert.ok(Array.isArray(es), "Examples must be an array");
+        es = es.map((e) => {
+          return Array.isArray(e) ? e.join(" ") : e;
+        });
+        return this.__setProp("examples", es, { allowOverride: true });
+      }
+      /**
+       * Returns a JSON Schema. It exists for compatibility with fluent-schema.
+       */
+      valueOf() {
+        return this.jsonSchema();
+      }
+      /**
+       * The visitable in a visitor pattern. Used for exporting schema.
+       * @param {Exporter} visitor a schema exporter. @see JSONSchemaExporter
+       */
+      // istanbul ignore next
+      export(visitor) {
+        throw new Error("Subclass must override");
+      }
+      properties() {
+        return this.__properties;
+      }
+      /**
+       * @return JSON Schema with the schema version keyword at the root level.
+       */
+      jsonSchema() {
+        const exporter = new JSONSchemaExporter();
+        return exporter.export(this);
+      }
+      /**
+       * Returns a validator function which throws ValidationError if the value it
+       * is asked to validate does not match the schema.
+       *
+       * Locks the current schema.
+       *
+       * @param {string} name the name of this schema (to distinguish errors)
+       * @param {*} [compiler] the ajv or equivalent JSON schema compiler to use
+       * @param {returnSchemaToo} [returnSchemaToo] whether to return jsonSchema as
+       *   well as the validator
+       * @returns {Function} call on a value to validate it; throws on error
+       */
+      compile(name, compiler, returnSchemaToo) {
+        assert.ok(name, "name is required");
+        if (!compiler) {
+          if (!ajv) {
+            ajv = new (require("ajv"))({
+              allErrors: true,
+              useDefaults: true,
+              strictSchema: false
+            });
+          }
+          compiler = ajv;
+        }
+        this.lock();
+        const jsonSchema = this.jsonSchema();
+        const validate2 = compiler.compile(jsonSchema);
+        const assertValid = (v) => {
+          if (!validate2(v)) {
+            throw new ValidationError(name, v, validate2.errors, jsonSchema);
+          }
+        };
+        if (returnSchemaToo) {
+          return { jsonSchema, assertValid };
+        }
+        return assertValid;
+      }
+      /**
+       * See {@link compile}.
+       * @returns {Object} contains jsonSchema and assertValid
+       */
+      getValidatorAndJSONSchema(name, compiler) {
+        return this.compile(name, compiler, true);
+      }
+      /**
+       * @return A copy of the Todea Schema object. Locked objects become unlocked.
+       *
+       */
+      copy() {
+        const ret = new this.constructor();
+        ret.__properties = deepcopy(this.__properties);
+        ret.__isOptional = this.__isOptional;
+        return ret;
+      }
+      // max / min support
+      /**
+       * Validate input to min/max.
+       * @param {String} name Property name
+       * @param {Integer} val A non-negative integer for min/max.
+       */
+      __validateRangeProperty(name, val) {
+        assert.ok(Number.isInteger(val), `${name} must be an integer`);
+        assert.ok(val >= 0, `${name} must be a non-negative number`);
+      }
+      /**
+       * Set a min property depending on schema type.
+       * @param {Integer} val A non-negative integer for min/max.
+       */
+      min(val) {
+        const name = this.constructor.MIN_PROP_NAME;
+        this.__validateRangeProperty(name, val);
+        const max = this.getProp(this.constructor.MAX_PROP_NAME);
+        assert.ok(max === void 0 || max >= val, "min must be less than max");
+        return this.__setProp(name, val);
+      }
+      /**
+       * Set a max property depending on schema type.
+       * @param {Integer} val A non-negative integer for min/max.
+       */
+      max(val) {
+        const name = this.constructor.MAX_PROP_NAME;
+        this.__validateRangeProperty(name, val);
+        const min = this.getProp(this.constructor.MIN_PROP_NAME);
+        assert.ok(min === void 0 || min <= val, "max must be more than min");
+        return this.__setProp(name, val);
+      }
+    };
+    var ObjectSchema = class extends BaseSchema {
+      static JSON_SCHEMA_TYPE = "object";
+      static MAX_PROP_NAME = "maxProperties";
+      static MIN_PROP_NAME = "minProperties";
+      /**
+       * Creates an object schema object.
+       * @param {Object} [props={}] Keys must be strings, values must be schema
+       *   objects. Passing props is the same as calling S.obj().props(props).
+       */
+      constructor(props = {}) {
+        super();
+        this.objectSchemas = {};
+        this.patternSchemas = {};
+        this.props(props);
+      }
+      /**
+       * Set an object schema's object property.
+       * @param {String} name The name of the property.
+       * @param {BaseSchema} schema Any subclass of BaseSchema. Schema gets locked.
+       */
+      prop(name, schema) {
+        assert.ok(
+          !this.__isLocked,
+          "Schema is locked. Call copy then further modify the schema"
+        );
+        assert.ok(typeof name === "string", "Property name must be strings.");
+        const properties = this.__setDefaultProp("properties", {});
+        assert.ok(
+          !Object.prototype.hasOwnProperty.call(properties, name),
+          `Property with key ${name} already exists`
+        );
+        assert.ok(schema !== void 0, `Property ${name} must define a schema`);
+        this.objectSchemas[name] = schema.lock();
+        properties[name] = schema.properties();
+        if (schema.required) {
+          this.__setDefaultProp("required", []).push(name);
+        }
+        return this;
+      }
+      /**
+       * A mapping of property names to schemas. Calls this.prop() in a loop.
+       * @param {Object} props Keys must be strings, values must be schema
+       *   objects.
+       */
+      props(props) {
+        for (const [name, p] of Object.entries(props)) {
+          this.prop(name, p);
+        }
+        return this;
+      }
+      /**
+       * A mapping of propertyProperties to schemas.
+       * @param {Object} props Keys must be regex, values must be schema
+       */
+      patternProps(props) {
+        for (const [name, schema] of Object.entries(props)) {
+          const properties = this.__setDefaultProp("patternProperties", {});
+          assert.ok(
+            !Object.prototype.hasOwnProperty.call(properties, name),
+            `Pattern ${name} already exists`
+          );
+          const anchoredName = getAnchoredPattern(name);
+          this.patternSchemas[anchoredName] = schema.lock();
+          properties[anchoredName] = schema.properties();
+        }
+        return this;
+      }
+      copy() {
+        const ret = super.copy();
+        Object.assign(ret.objectSchemas, this.objectSchemas);
+        Object.assign(ret.patternSchemas, this.patternSchemas);
+        return ret;
+      }
+      properties() {
+        const ret = super.properties();
+        const hasProperty = Object.keys(this.objectSchemas).length > 0 || Object.keys(this.patternSchemas).length > 0;
+        const hasAdditionalProperties = !!this.additionalProperties;
+        ret.additionalProperties = !hasProperty || hasAdditionalProperties;
+        return ret;
+      }
+      export(visitor) {
+        return visitor.exportObject(this);
+      }
+    };
+    var ArraySchema = class extends BaseSchema {
+      static JSON_SCHEMA_TYPE = "array";
+      static MAX_PROP_NAME = "maxItems";
+      static MIN_PROP_NAME = "minItems";
+      /**
+       * Creates an array schema object.
+       * @param {BaseSchema} [items] An optional parameter to items(). If provided,
+       *   it is the same as calling S.arr().items(items).
+       */
+      constructor(items) {
+        super();
+        this.itemsSchema = void 0;
+        if (items) {
+          this.items(items);
+        }
+      }
+      /**
+       * Set the schema for items in array
+       * @param {BaseSchema} items Any subclass of BaseSchema. Schema gets locked.
+       */
+      items(items) {
+        assert.ok(!this.itemsSchema, "Items is already set.");
+        this.itemsSchema = items.lock();
+        this.__setProp("items", items.properties());
+        return this;
+      }
+      copy() {
+        const ret = super.copy();
+        ret.itemsSchema = this.itemsSchema;
+        return ret;
+      }
+      export(visitor) {
+        return visitor.exportArray(this);
+      }
+    };
+    var NumberSchema = class extends BaseSchema {
+      static JSON_SCHEMA_TYPE = "number";
+      static MAX_PROP_NAME = "maximum";
+      static MIN_PROP_NAME = "minimum";
+      constructor() {
+        super();
+        this.__isFloat = false;
+      }
+      /**
+       * Validate input to min/max.
+       * @param {String} name Property name
+       * @param {Integer} val A finite number for min/max.
+       */
+      __validateRangeProperty(name, val) {
+        assert.ok(Number.isFinite(val), `${name} must be a number`);
+      }
+      asFloat() {
+        assert(!this.__isLocked, "Schema is locked");
+        this.__isFloat = true;
+        return this;
+      }
+      get isFloat() {
+        return this.__isFloat;
+      }
+      export(visitor) {
+        return visitor.exportNumber(this);
+      }
+      copy() {
+        const ret = super.copy();
+        ret.__isFloat = this.__isFloat;
+        return ret;
+      }
+    };
+    var IntegerSchema = class extends NumberSchema {
+      static JSON_SCHEMA_TYPE = "integer";
+      /**
+       * Validate input to min/max.
+       * @param {String} name Property name
+       * @param {Integer} val An integer for min/max.
+       */
+      __validateRangeProperty(name, val) {
+        assert.ok(Number.isInteger(val), `${name} must be an integer`);
+      }
+      /**
+       * sets limit on how large max or min can be.
+       * Validates current min/max to ensure they work correctly
+       */
+      __setSafeRangeLimit(val) {
+        const max = this.getProp(this.constructor.MAX_PROP_NAME);
+        if (max === void 0) {
+          this.max(val);
+        } else {
+          assert.ok(max <= val, `max cannot exceed ${val}`);
+        }
+        const min = this.getProp(this.constructor.MIN_PROP_NAME);
+        if (min === void 0) {
+          this.min(-val);
+        } else {
+          assert.ok(min >= -val, `min must be larger than ${-val}`);
+        }
+        return this;
+      }
+      /**
+       * applies range for Int32 values
+       */
+      asInt32() {
+        return this.__setSafeRangeLimit(INT32_MAX);
+      }
+      /**
+       * applies range for int64 values
+       */
+      asInt64() {
+        return this.__setSafeRangeLimit(INT64_MAX);
+      }
+      asFloat = void 0;
+      export(visitor) {
+        return visitor.exportInteger(this);
+      }
+    };
+    var StringSchema = class extends BaseSchema {
+      static JSON_SCHEMA_TYPE = "string";
+      static MAX_PROP_NAME = "maxLength";
+      static MIN_PROP_NAME = "minLength";
+      /**
+       * Set valid values for the string schema.
+       * @param {Array<String>} validValues Valid values for the string. There must
+       *   be at least 2 valid values.
+       */
+      enum(validValues) {
+        const values = Array.isArray(validValues) ? validValues : [...arguments];
+        assert(values.length >= 1, "Enum must contain at least 1 value.");
+        return this.__setProp("enum", values);
+      }
+      /**
+       * A pattern for the string.
+       * @param {String|RegExp} pattern The pattern for the string. Can be a string
+       *   with regex syntax, or a RegExp object.
+       */
+      pattern(pattern) {
+        if (pattern instanceof RegExp) {
+          pattern = pattern.source;
+        }
+        assert(typeof pattern === "string", "Pattern must be a string");
+        const anchoredPattern = getAnchoredPattern(pattern);
+        return this.__setProp("pattern", anchoredPattern);
+      }
+      export(visitor) {
+        return visitor.exportString(this);
+      }
+    };
+    var BooleanSchema = class extends BaseSchema {
+      static JSON_SCHEMA_TYPE = "boolean";
+      export(visitor) {
+        return visitor.exportBoolean(this);
+      }
+    };
+    var MapSchema = class extends ObjectSchema {
+      constructor() {
+        super();
+        this.prop = void 0;
+        this.props = void 0;
+        this.patternProps = void 0;
+        this.finalized = false;
+        this.keySchema = void 0;
+        this.valueSchema = void 0;
+      }
+      /**
+       * Set a key pattern for the map.
+       * @param {String} keyPattern A pattern for keys
+       */
+      keyPattern(pattern) {
+        assert(!this.keySchema, "key pattern already set");
+        this.keySchema = S2.str.pattern(pattern).lock();
+        this.__tryFinalizeSchema();
+        return this;
+      }
+      /**
+       * Set a value schema for the map.
+       * @param {BaseSchema} value Any subclass of BaseSchema for the values of map
+       */
+      value(value) {
+        assert(!this.valueSchema, "value schema already set");
+        assert(value.required, "value must be required");
+        this.valueSchema = value.lock();
+        this.__tryFinalizeSchema();
+        return this;
+      }
+      lock() {
+        this.__finalizeSchema();
+        return super.lock();
+      }
+      __finalizeSchema() {
+        assert(this.valueSchema, "Must have a value schema");
+        if (!this.keySchema) {
+          this.keySchema = S2.str;
+        }
+        this.__tryFinalizeSchema();
+      }
+      __tryFinalizeSchema() {
+        if (this.keySchema && this.valueSchema && !this.finalized) {
+          this.finalized = true;
+          super.patternProps({
+            [this.keySchema?.getProp("pattern") ?? ".*"]: this.valueSchema
+          });
+        }
+      }
+      export(visitor) {
+        this.__finalizeSchema();
+        return visitor.exportMap(this);
+      }
+      copy() {
+        const ret = super.copy();
+        ret.finalized = this.finalized;
+        ret.keySchema = this.keySchema.copy();
+        ret.valueSchema = this.valueSchema.copy();
+        return ret;
+      }
+    };
+    var MediaSchema = class extends StringSchema {
+      type(t) {
+        this.__setProp("contentMediaType", t);
+        return this;
+      }
+      encoding(e) {
+        assert(
+          ["binary", "base64", "utf-8"].includes(e),
+          "Encoding must be binary, base64 or utf-8"
+        );
+        this.__setProp("contentEncoding", e);
+        return this;
+      }
+      export(visitor) {
+        return visitor.exportMedia(this);
+      }
+    };
+    var JSONSchemaExporter = class {
+      constructor() {
+        const methods = [
+          "exportString",
+          "exportInteger",
+          "exportNumber",
+          "exportObject",
+          "exportArray",
+          "exportBoolean",
+          "exportMap",
+          "exportMedia"
+        ];
+        for (const method of methods) {
+          Object.defineProperty(this, method, {
+            get: () => {
+              return (schema) => {
+                return schema.properties();
+              };
+            }
+          });
+        }
+      }
+      export(schema) {
+        const ret = deepcopy(schema.export(this));
+        ret.$schema = "http://json-schema.org/draft-07/schema#";
+        return ret;
+      }
+    };
+    var S2 = class _S {
+      /**
+       * @param {Object} object See {@link ObjectSchema#constructor}
+       * @return A new ObjectSchema object.
+       */
+      static obj(object) {
+        return new ObjectSchema(object);
+      }
+      /**
+       * @param {BaseSchema} schema See {@link ArraySchema#constructor}
+       * @return A new ArraySchema object.
+       */
+      static arr(schema) {
+        return new ArraySchema(schema);
+      }
+      /**
+       * Get a new NumberSchema object.
+       */
+      static get double() {
+        return new NumberSchema();
+      }
+      /**
+       * Get a new IntegerSchema object.
+       */
+      static get int() {
+        return new IntegerSchema();
+      }
+      /**
+       * Get a new StringSchema object.
+       */
+      static get str() {
+        return new StringSchema();
+      }
+      /**
+       * Get a new BooleanSchema object.
+       */
+      static get bool() {
+        return new BooleanSchema();
+      }
+      /**
+       * Get a new MapSchema object.
+       */
+      static get map() {
+        return new MapSchema();
+      }
+      /**
+       * Get a new MediaSchema object.
+       */
+      static get media() {
+        return new MediaSchema();
+      }
+      /**
+       * Lock all schemas in a dictionary (in-place).
+       * @param {Object<Schema>} schemas a map of schema values
+       * @returns the input map of schema values
+       */
+      static lock(schemas) {
+        Object.values(schemas).forEach((x) => x.lock());
+        return schemas;
+      }
+      /**
+       * Sets all schemas as optional (in-place).
+       * @param {Object<Schema>} schemas a map of schema values
+       * @returns the input map of schema values
+       */
+      static optional(schemas) {
+        Object.values(schemas).forEach((x) => x.optional());
+        return schemas;
+      }
+      static PATTERN = {
+        UUID_PATTERN: /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/
+      };
+      /**
+       * Common schemas.
+       */
+      static SCHEMAS = _S.lock({
+        UUID: _S.str.desc("An UUID. It is normally generated by calling uuidv4().").pattern(_S.PATTERN.UUID_PATTERN),
+        STR_ANDU: _S.str.desc("Only hyphens, underscores, letters and numbers are permitted.").pattern(/^[-_a-zA-Z0-9]+$/),
+        // oversimplified, quick regex to check that a string looks like an email
+        STR_EMAIL: _S.str.pattern(/^[^A-Z ]+@.+$/).desc("an e-mail address (lowercase only)").lock(),
+        TIMESTAMP: _S.str.pattern(/\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d{3}Z/).desc(`An UTC timestamp with millisecond precision, for example,
+        2021-02-15T20:15:59.321Z`),
+        TIMESTAMP_WITH_TZ: _S.str.pattern(/\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(\.\d*)?([+-][0-2]\d:[0-5]\d|Z)/).desc(`Timestamp with time zone and optional millisecond precision,
+        for example,
+        2021-02-15T20:15:59Z,
+        2022-09-15T16:48:28.9097226Z,
+        2021-02-15T11:55:20-05:00,
+        2021-02-15T11:55:20.9097226+08:00`),
+        EPOCH_IN_SECONDS: _S.int.min(EPOCH_IN_SECONDS_MIN).max(EPOCH_IN_SECONDS_MAX).desc(`Unix epoch time format in seconds from
+        ${TIMESTAMP_MIN} to ${TIMESTAMP_MAX}.`),
+        EPOCH_IN_MILLISECONDS: _S.int.min(EPOCH_IN_MILLISECONDS_MIN).max(EPOCH_IN_MILLISECONDS_MAX).desc(`Unix epoch time format in
+        milliseconds from ${TIMESTAMP_MIN} to ${TIMESTAMP_MAX}.`).asInt64()
+      });
+      /** Thrown if validation fails. */
+      static ValidationError = ValidationError;
+      static INT32_MAX = INT32_MAX;
+      static INT32_MIN = INT32_MIN;
+      static INT64_MAX = INT64_MAX;
+      static INT64_MIN = INT64_MIN;
+    };
+    function getAnchoredPattern(pattern) {
+      let anchoredName = pattern;
+      if (pattern[0] !== "^") {
+        anchoredName = "^" + pattern;
+      }
+      if (pattern[pattern.length - 1] !== "$") {
+        anchoredName += "$";
+      }
+      return anchoredName;
+    }
+    module2.exports = S2;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VERSION: () => VERSION,
+  specSchema: () => spec_schema_default2,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// package.json
+var package_default = {
+  name: "@polytric/openws-spec",
+  version: "0.0.2",
+  description: "Polytric OpenWS Specification",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./builder": {
+      types: "./dist/builder.d.ts",
+      import: "./dist/builder.js",
+      require: "./dist/builder.cjs"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js",
+      require: "./dist/types.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  keywords: [
+    "openws",
+    "specification",
+    "websocket"
+  ],
+  author: "Polytric",
+  license: "Apache-2.0",
+  scripts: {
+    build: "pnpm emit && tsup",
+    emit: `tsx -e "import schema from './src/spec-schema.ts'; console.log(JSON.stringify(schema.jsonSchema()))" > ./src/spec-schema.json`,
+    prepublishOnly: "pnpm build",
+    "test:builder": "nodemon -w dist -w test/builder.cjs test/builder.cjs",
+    "test:validate": "tsx test/validate-spec.ts",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    ajv: "^8.17.1"
+  },
+  devDependencies: {
+    "@pocketgems/schema": "^0.1.3",
+    nodemon: "^3.1.11",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  },
+  packageManager: "pnpm@10.26.1",
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/spec-schema.ts
+var import_schema = __toESM(require_schema(), 1);
+var keyPattern = "[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?";
+var messageSchema = import_schema.default.obj({
+  payload: import_schema.default.obj({}).desc(
+    "Must be a valid JSON schema spec. For brevity, openws omits this spec, but implementations should valid this"
+  ),
+  description: import_schema.default.str.optional(),
+  from: import_schema.default.arr(import_schema.default.str).desc("A list of roles that can send this message").optional()
+});
+messageSchema.additionalProperties = true;
+var endpointSchema = import_schema.default.obj({
+  host: import_schema.default.str,
+  port: import_schema.default.int.min(1).max(65535),
+  path: import_schema.default.str
+});
+endpointSchema.additionalProperties = true;
+var roleSchema = import_schema.default.obj({
+  endpoints: import_schema.default.arr(endpointSchema).min(1).optional().desc(
+    "A role can declare an endpoint to accept connections from other roles, normally used by servers"
+  ),
+  messages: import_schema.default.map.keyPattern(keyPattern).value(messageSchema).desc(
+    "A message accepted by the role and handled by the role, and roles can send messages other roles accepts. The OpenWS spec only defines the shape of the payload, and how things get encoded / decoded on the wire, it doesn't determine behavior (through through description the behavior can be documented)."
+  ),
+  description: import_schema.default.str.optional()
+});
+roleSchema.additionalProperties = true;
+var networkSchema = import_schema.default.obj({
+  roles: import_schema.default.map.min(1).keyPattern(keyPattern).desc(
+    "A network is a collection of roles that exchange messages. Multiple roles can coexist in the same network. The simplest network contains a server-client pair."
+  ).value(roleSchema),
+  description: import_schema.default.str.optional()
+});
+networkSchema.additionalProperties = true;
+var openWsSchema = import_schema.default.obj({
+  openws: import_schema.default.str.enum("0.0.1", "0.0.2").desc("The OpenWS schema version"),
+  title: import_schema.default.str.desc("A title for the overall system.").optional(),
+  description: import_schema.default.str.desc(
+    "A high level description of the overall system, including all networks and all roles"
+  ).optional(),
+  version: import_schema.default.str.desc("A version string").optional(),
+  networks: import_schema.default.map.min(1).keyPattern(keyPattern).value(networkSchema)
+});
+openWsSchema.additionalProperties = true;
+var spec_schema_default = openWsSchema;
+
+// src/spec-schema.json
+var spec_schema_default2 = { type: "object", properties: { openws: { type: "string", enum: ["0.0.1", "0.0.2"], description: "The OpenWS schema version" }, title: { type: "string", description: "A title for the overall system." }, description: { type: "string", description: "A high level description of the overall system, including all networks and all roles" }, version: { type: "string", description: "A version string" }, networks: { type: "object", minProperties: 1, patternProperties: { "^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$": { type: "object", properties: { roles: { type: "object", minProperties: 1, description: "A network is a collection of roles that exchange messages. Multiple roles can coexist in the same network. The simplest network contains a server-client pair.", patternProperties: { "^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$": { type: "object", properties: { endpoints: { type: "array", items: { type: "object", properties: { host: { type: "string" }, port: { type: "integer", minimum: 1, maximum: 65535 }, path: { type: "string" } }, required: ["host", "port", "path"], additionalProperties: true }, minItems: 1, description: "A role can declare an endpoint to accept connections from other roles, normally used by servers" }, messages: { type: "object", patternProperties: { "^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$": { type: "object", properties: { payload: { type: "object", description: "Must be a valid JSON schema spec. For brevity, openws omits this spec, but implementations should valid this", additionalProperties: true }, description: { type: "string" }, from: { type: "array", items: { type: "string" }, description: "A list of roles that can send this message" } }, required: ["payload"], additionalProperties: true } }, description: "A message accepted by the role and handled by the role, and roles can send messages other roles accepts. The OpenWS spec only defines the shape of the payload, and how things get encoded / decoded on the wire, it doesn't determine behavior (through through description the behavior can be documented).", additionalProperties: false }, description: { type: "string" } }, required: ["messages"], additionalProperties: true } }, additionalProperties: false }, description: { type: "string" } }, required: ["roles"], additionalProperties: true } }, additionalProperties: false } }, required: ["openws", "networks"], additionalProperties: true, $schema: "http://json-schema.org/draft-07/schema#" };
+
+// src/index.ts
+var VERSION = package_default.version;
+var validator;
+function validate(spec) {
+  validator = validator ?? spec_schema_default.compile("Validator");
+  validator(spec);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION,
+  specSchema,
+  validate
+});
+//# sourceMappingURL=index.cjs.map