@roster-lock/shared 0.1.0

package/src/match-lock-file/match-config/version-1/lock/engine/caster-json-schema/schema.ts

@@ -0,0 +1,47 @@
+import { JSONSchemaType } from "ajv";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+
+import { assetsSchema, assetKeywords } from "./asset";
+import { requirementsSchema, requirementKeywords } from "./requirements";
+import { pathVariablesSchema, pathVariableKeywords } from "./variables";
+import { officialSelectionsSchema, officialSelectionsKeywords } from "./officialSelections";
+
+const pieceDefinitionSchema: JSONSchemaType<
+  RosterLockEngineConfig["pieceDefinitions"][string]
+> = {
+  type: "object",
+  required: ["selectionStrategy", "requires", "pathVariables", "assets"],
+  additionalProperties: false,
+  properties: {
+    selectionStrategy: { type: "string", enum: ["mandatory", "personal", "shared", "on demand"] },
+    pathVariables: pathVariablesSchema,
+    requires: requirementsSchema,
+    assets: assetsSchema,
+  },
+}
+
+export const engineSchema: JSONSchemaType<RosterLockEngineConfig> = {
+  type: "object",
+  required: ["name", "version", "pieceDefinitions"],
+  additionalProperties: false,
+  properties: {
+    name: { type: "string" },
+    version: { type: "string" },
+    pieceDefinitions: {
+      type: "object",
+      required: [],
+      additionalProperties: pieceDefinitionSchema
+    },
+    officialSelections: { ...officialSelectionsSchema, nullable: true },
+  }
+}
+
+export const engineKeywords = [
+  ...pathVariableKeywords,
+  ...requirementKeywords,
+  ...assetKeywords,
+  ...officialSelectionsKeywords,
+]
+

package/src/match-lock-file/match-config/version-1/lock/engine/caster-json-schema/variables/index.ts

@@ -0,0 +1,22 @@
+
+import { JSONSchemaType } from "ajv";
+import { pathVariableListSchemaValidator, pathVariableNameSchemaValidator } from "./keywords";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+export const pathVariableKeywords = [
+  pathVariableListSchemaValidator,
+  pathVariableNameSchemaValidator,
+]
+
+
+export const pathVariablesSchema: JSONSchemaType<
+  RosterLockEngineConfig["pieceDefinitions"][string]["pathVariables"]
+> = {
+  [pathVariableListSchemaValidator.keyword]: true,
+  type: "array",
+  items: {
+    [pathVariableNameSchemaValidator.keyword]: true,
+    type: "string",
+  },
+}

package/src/match-lock-file/match-config/version-1/lock/engine/caster-json-schema/variables/keywords.ts

@@ -0,0 +1,14 @@
+import { defineKeyword } from "../../../../../../util-types/json-schema";
+
+import { validatePathVariables, validatePathVariableName } from "../../validate/piece/path-variables";
+export const pathVariableListSchemaValidator = defineKeyword({
+  keyword: "enginePathVariableList",
+  type: "array",
+  validate: validatePathVariables
+})
+
+export const pathVariableNameSchemaValidator = defineKeyword({
+  keyword: "enginePathVariableName",
+  type: "string",
+  validate: validatePathVariableName
+})

package/src/match-lock-file/match-config/version-1/lock/engine/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./validate";
+export * from "./caster-json-schema";

package/src/match-lock-file/match-config/version-1/lock/engine/validate/constants.ts

@@ -0,0 +1,7 @@
+
+
+export class ShouldntHappenError extends Error {
+  constructor(message: string){
+    super(message);
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/error.ts

@@ -0,0 +1,21 @@
+
+
+export class ValidationErrorPath extends Error {
+  path = "/";
+  constructor(message: string){
+    super(message);
+  }
+  addPathPrefix(part: string){
+    this.path = `/${part}${this.path}`;
+  }
+  addPathSuffix(part: string){
+    this.path = `${this.path}/${part}`;
+  }
+  static convertError(e: unknown){
+    if(!(e instanceof Error)) throw e;
+    if(!(e instanceof ValidationErrorPath)){
+      e = new ValidationErrorPath(e.message);
+    }
+    return e as ValidationErrorPath;
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/index.ts

@@ -0,0 +1,18 @@
+
+import { validatePieceDefinition } from "./piece";
+import { RosterLockV1Config } from "@roster-lock/types";
+
+export * from "./piece";
+import { ValidationErrorPath } from "./error";
+
+export function validateEngineConfig(engine: RosterLockV1Config["engine"]){
+  for(const [pieceType, definition] of Object.entries(engine.pieceDefinitions)){
+    try {
+      validatePieceDefinition(pieceType, definition, engine);
+    }catch(e){
+      const eTyped = ValidationErrorPath.convertError(e);
+      eTyped.addPathPrefix(`pieceDefinitions/${pieceType}`);
+      throw e;
+    }
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/assets/glob/filepath-component.ts

@@ -0,0 +1,41 @@
+
+const WINDOWS_RESERVED_NAMES = [
+  'CON', 'PRN', 'AUX', 'NUL',
+  'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+  'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'
+];
+
+export function isValidPathComponent(component: string) {
+  // Empty components are invalid
+  if(component.length === 0){
+    throw new Error("Filepath component is empty");
+  }
+
+  // Check component length (most filesystems have per-component limits)
+  if(component.length > 255){
+    throw new Error("Filepath component is too long");
+  }
+
+  // Reserved names on Windows (even on other platforms, better to be safe)
+  const upperComponent = component.toUpperCase();
+  const baseName = upperComponent.split('.')[0]; // Remove extension for check
+  if(WINDOWS_RESERVED_NAMES.includes(baseName)){
+    throw new Error("Filepath component is a reserved name");
+  }
+
+  // Must not start or end with spaces (problematic on Windows)
+  // Note: Leading dots are actually valid (hidden files on Unix)
+  if(component.startsWith(' ') || component.endsWith(' ')){
+    throw new Error("Filepath component has leading/trailing spaces");
+  }
+
+  // Must not end with dots (problematic on Windows)
+  if(component.endsWith('.')){
+    throw new Error("Filepath component ends with a dot");
+  }
+
+  // Must not be just dots
+  if(/^\.+$/.test(component)){
+    throw new Error("Filepath component is just dots");
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/assets/glob/filepath.ts

@@ -0,0 +1,55 @@
+
+import { isValidPathComponent } from "./filepath-component";
+export function isValidFilePath(path: string) {
+  // Comprehensive validation for file paths
+  if(path.length === 0){
+    throw new Error("Filepath is empty");
+  }
+
+  // Check path length limits (most filesystems have limits)
+  if(path.length > 4096){
+    throw new Error("Filepath is too long");
+  }
+
+  // Only forward slashes allowed - reject backslashes for cross-platform consistency
+  if(path.includes('\\')){
+    throw new Error("Filepath contains backslash - use forward slashes only");
+  }
+
+  // Check for invalid characters across different platforms
+  // Windows: < > : " | ? * and control characters (0x00-0x1f)
+  // Unix/Linux: null character (0x00) and forward slash in filenames
+  // We'll be restrictive and block characters that are problematic on any major platform
+  const invalidChars = /[<>:"|?*\x00-\x1f\x7f]/;
+  if(invalidChars.test(path)){
+    throw new Error("Filepath contains invalid characters");
+  }
+
+  // Check for relative path traversal attempts
+  if(
+    path.includes('../') ||
+    path.includes('/..') ||
+    path === '..' ||
+    path.startsWith('../') ||
+    path.endsWith('/..')
+  ){
+    throw new Error("Filepath contains invalid traversal");
+  }
+
+  // Must not end with a slash (indicating a directory)
+  if(path.endsWith('/')){
+    throw new Error("Filepath ends with a slash");
+  }
+
+  // Split into path components and validate each
+  const components = path.split('/');
+  for(const component of components){
+    isValidPathComponent(component);
+  }
+
+  // Must have at least one component (the filename)
+  if(components.length === 0){
+    throw new Error("Filepath has no components");
+  }
+}
+

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/assets/glob/index.ts

@@ -0,0 +1,21 @@
+import isGlob from "is-glob";
+
+export { validatePathVariablesInGlob } from "./pathvariables";
+import { replacePathVariablesWithGlob } from "./pathvariables";
+import { isValidFilePath } from "./filepath";
+export function validateGlobItem(pattern: string) {
+  // First, check if the glob uses any undefined path variables
+  pattern = replacePathVariablesWithGlob(pattern);
+
+  // Check for absolute paths (we want relative paths only)
+  if(pattern.startsWith('/') || /^[a-zA-Z]:/.test(pattern)){
+    throw new Error("File pattern is absolute");
+  }
+
+  // If it's a valid glob pattern, accept it
+  if(isGlob(pattern)) return;
+
+  // If it's not a glob, check if it's a valid file path
+  isValidFilePath(pattern);
+}
+

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/assets/glob/pathvariables.ts

@@ -0,0 +1,28 @@
+
+export const PATH_VARIABLE_VALUE_VALIDATION = {
+  minLength: 1,
+  maxLength: 64,
+  charset: 'a-zA-Z0-9_\\- ',
+};
+
+export function validatePathVariablesInGlob(
+  glob: string, pathVariables: Array<string>
+){
+  const pathVariableRegex = /<([a-zA-Z0-9_\\-]+)>/g;
+  let match: RegExpExecArray | null;
+  while((match = pathVariableRegex.exec(glob)) !== null){
+    const variable = match[1];
+    if(!pathVariables.includes(variable)){
+      throw new Error(`Glob ${glob} uses undefined path variable ${variable}`);
+    }
+  }
+}
+
+export function replacePathVariablesWithGlob(
+  glob: string
+){
+  return glob.replaceAll(
+    /<([a-zA-Z0-9_\\-]+)>/g,
+    `[[${PATH_VARIABLE_VALUE_VALIDATION.charset}]+]{${PATH_VARIABLE_VALUE_VALIDATION.minLength},${PATH_VARIABLE_VALUE_VALIDATION.maxLength}}`
+  );
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/assets/index.ts

@@ -0,0 +1,46 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+type EngineAssetDefinition = RosterLockEngineConfig["pieceDefinitions"][string]["assets"][number];
+
+import { validateCount } from "../../../../../shared/count";
+
+export function validateAsset(
+  pieceAssetDefinition: RosterLockEngineConfig["pieceDefinitions"][string]["assets"][0],
+  definition: RosterLockEngineConfig["pieceDefinitions"][string]
+){
+  validateAssetName(pieceAssetDefinition.name, definition.assets);
+  validateCount(pieceAssetDefinition.count);
+  validateGlobList(pieceAssetDefinition.glob);
+  for(const g of pieceAssetDefinition.glob){
+    validatePathVariablesInGlob(g, definition.pathVariables);
+    validateGlobItem(g);
+  }
+}
+
+export function validateAssetName(
+  name: EngineAssetDefinition["name"], assets: RosterLockEngineConfig["pieceDefinitions"][string]["assets"]
+){
+  if(name === ""){
+    throw new Error("Name is empty");
+  }
+  if(name !== name.trim()){
+    throw new Error("Name contains a trailing or leading space");
+  }
+  if(assets.filter((a) => a.name === name).length > 1){
+    throw new Error("Duplicate name");
+  }
+}
+
+import { validatePathVariablesInGlob, validateGlobItem } from "./glob";
+export function validateGlobList(
+  glob: EngineAssetDefinition["glob"],
+){
+  if(glob.length === 0){
+    throw new Error("Expecting at least 1 glob");
+  }
+  if(new Set(glob).size !== glob.length){
+    throw new Error("Has duplicate globs");
+  }
+}
+
+export { validatePathVariablesInGlob, validateGlobItem };

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/index.ts

@@ -0,0 +1,37 @@
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+export * from "./requirements";
+export * from "./path-variables";
+export * from "./assets";
+import { validatePathVariableName, validatePathVariables } from "./path-variables";
+import { validateAsset } from "./assets";
+import {
+  validatePieceInCycles, validatePieceRequirementList, validatePieceRequirementIsResolved
+} from "./requirements";
+import { ValidationErrorPath } from "../error";
+
+export function validatePieceDefinition(
+  pieceType: string, definition: RosterLockEngineConfig["pieceDefinitions"][string], engine: RosterLockEngineConfig
+){
+  validatePieceRequirementList(definition.requires);
+  for(const requiredPieceType of definition.requires){
+    validatePieceRequirementIsResolved(requiredPieceType, engine);
+  }
+  validatePathVariables(definition.pathVariables);
+  for(const variable of definition.pathVariables){
+    validatePathVariableName(variable);
+  }
+  for(const asset of definition.assets){
+    try {
+      validateAsset(asset, definition);
+    }catch(e){
+      const eTyped = ValidationErrorPath.convertError(e);
+      eTyped.addPathPrefix(`assets/${asset.name}`);
+      throw e;
+    }
+  }
+  validatePieceInCycles(pieceType, engine);
+}
+
+

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/path-variables.ts

@@ -0,0 +1,21 @@
+
+export function validatePathVariables(variables: Array<string>){
+  if(new Set(variables).size !== variables.length){
+    throw new Error(`Duplicate path variables`);
+  }
+}
+
+// Note: [^CHARS] specifies we're looking for characters that are NOT in the set
+const INVALID_PATH_VARIABLE_CHARS = /[^a-zA-Z0-9_]/;
+export function validatePathVariableName(variable: string){
+  if(variable.length === 0){
+    throw new Error(`Path variable is empty`);
+  }
+  if(variable.length > 64){
+    throw new Error(`Path variable ${variable} is too long`);
+  }
+  const match = variable.match(INVALID_PATH_VARIABLE_CHARS)
+  if(match){
+    throw new Error(`Path variable ${variable} contains invalid character: "${match[0]}"`);
+  }
+}

package/src/match-lock-file/match-config/version-1/lock/engine/validate/piece/requirements.ts

@@ -0,0 +1,117 @@
+import { findAllCycles, getCyclesUsingKey } from "@roster-lock/utils";
+import { RosterLockV1Config } from "@roster-lock/types";
+type RosterLockEngineConfig = RosterLockV1Config["engine"];
+
+
+export class CycleError extends Error {
+  constructor(public cycles: Array<Array<string>>){
+    super(`Piece requirements form a cycle`);
+  }
+  getCyclesOfPiece(pieceType: string){
+    return getCyclesUsingKey(pieceType, this.cycles);
+  }
+}
+
+export function validatePieceRequirementCycles(engine: RosterLockEngineConfig){
+  const pieceTypes = Object.keys(engine.pieceDefinitions);
+  const cycles = findAllCycles(pieceTypes, (pieceType) => engine.pieceDefinitions[pieceType].requires);
+  if(cycles.length > 0) throw new CycleError(cycles);
+}
+
+export function validatePieceInCycles(pieceType: string, engine: RosterLockEngineConfig){
+  const pieceTypes = Object.keys(engine.pieceDefinitions);
+  const cycles = findAllCycles(pieceTypes, (pieceType) => engine.pieceDefinitions[pieceType].requires);
+  if(cycles.length === 0) return;
+  const pieceCycles = getCyclesUsingKey(pieceType, cycles);
+  if(pieceCycles.length === 0) return;
+  throw new CycleError(pieceCycles);
+}
+
+export function validatePieceRequirementList(
+  requires: Array<string>
+){
+  if(requires.length === 0) return;
+  if(new Set(requires).size !== requires.length)
+    throw new Error(`Duplicate requires`);
+}
+
+export function validatePieceRequirementIsResolved(
+  requiredPieceType: RosterLockEngineConfig["pieceDefinitions"][string]["requires"][0],
+  engine: RosterLockEngineConfig
+){
+  const requiredDefinition = engine.pieceDefinitions[requiredPieceType];
+  if(!requiredDefinition){
+    throw new Error(`Non-existant piece ${requiredPieceType} required`);
+  }
+  if(requiredDefinition.selectionStrategy !== "on demand"){
+    throw new Error(`Non on-demand piece ${requiredPieceType} required`);
+  }
+}
+
+
+// 
+// This version tries to use the minimum amount of loops possible
+// Ensure that pieces not on demand can't be required by another non on demand piece
+// Ensure all on demand pieces are required by another piece
+export function eachPieceRequirementIsResolved_COMPLEX(engine: RosterLockEngineConfig){
+  const notOnDemandPieceTypes = new Set<string>();
+  const unusedOnDemandPieceTypes = new Set<string>();
+  const usedOnDemandPieceTypes = new Set<string>();
+  const expectedRequires = new Set<string>();
+  for(const [pieceType, definition] of Object.entries(engine.pieceDefinitions)){
+    // If the piece is on demand, we don't need to resolve it
+    if(definition.selectionStrategy === "on demand"){
+      if(usedOnDemandPieceTypes.has(pieceType)) continue;
+      expectedRequires.delete(pieceType);
+      unusedOnDemandPieceTypes.add(pieceType);
+
+      if(definition.requires.length === 0) continue;
+      if(new Set(definition.requires).size !== definition.requires.length)
+        throw new Error(`Piece ${pieceType} has duplicate requires`);
+      continue;
+    }
+
+    // If the piece is not on demand, It can't be required
+    if(expectedRequires.has(pieceType)){
+      throw new Error(`Piece ${pieceType} is required by another piece but is not an on demand piece`);
+    }
+    notOnDemandPieceTypes.add(pieceType);
+
+    // If we have no requirements, we're done
+    if(definition.requires.length === 0) continue;
+    if(new Set(definition.requires).size !== definition.requires.length)
+      throw new Error(`Piece ${pieceType} has duplicate requires`);
+
+    checkRequires(pieceType, definition);
+  }
+
+  if(expectedRequires.size > 0){
+    throw new Error(`The following pieces are required but not resolved: ${Array.from(expectedRequires).join(", ")}`);
+  }
+
+  function checkRequires(pieceType: string, definition: RosterLockEngineConfig["pieceDefinitions"][string]){
+
+    // Check each required piece type
+    for(const requiredPieceType of definition.requires){
+      // If the required piece type was already resolved, we're ok
+      if(notOnDemandPieceTypes.has(requiredPieceType)){
+        throw new Error(`Piece ${requiredPieceType} is required by another piece but is not an on demand piece`);
+      }
+
+      // If the required piece type was already used, we're ok
+      if(usedOnDemandPieceTypes.has(requiredPieceType)) continue;
+
+      // If the required piece type is on demand but wasn't used, we need to resolve it
+      if(unusedOnDemandPieceTypes.has(requiredPieceType)){
+        unusedOnDemandPieceTypes.delete(requiredPieceType);
+        usedOnDemandPieceTypes.add(requiredPieceType);
+        checkRequires(requiredPieceType, engine.pieceDefinitions[requiredPieceType]);
+        continue;
+      }
+
+      // Otherwise the on demand piece is not defined yet, we expect to find it later
+      expectedRequires.add(requiredPieceType);
+    }
+  }
+}
+

package/src/match-lock-file/match-config/version-1/lock/index.ts

@@ -0,0 +1,51 @@
+
+import { JSONSchemaType } from "ajv";
+import { JSONSchemaCaster } from "../../../util-types/json-schema";
+import { engineKeywords, engineSchema } from "./engine";
+export * from "./engine";
+import { rosterKeywords, rostersSchema } from "./rosters";
+export * from "./rosters";
+import { selectionKeywords, selectionConfigSchema  } from "./selection";
+export * from "./selection";
+import { pieceMetaKeywords, pieceMetaSchema } from "./piece-meta";
+export * from "./piece-meta";
+import { sharedKeywords } from "../shared";
+
+import { RosterLockV1Config } from "@roster-lock/types";
+
+import { buildIdentity } from "../shared";
+
+export const RosterLockV1Schema: JSONSchemaType<RosterLockV1Config> =   {
+  type: "object",
+  required: [
+    "configIdentity",
+    "author", "title", "version",
+    "engine", "rosters", "selection", "pieceMeta"
+  ],
+  additionalProperties: false,
+  properties: {
+    configIdentity: buildIdentity("lock", 1),
+
+    author: { type: "string" },
+    title: { type: "string" },
+    version: { type: "string" },
+
+    engine: engineSchema,
+    rosters: rostersSchema,
+    selection: selectionConfigSchema,
+    pieceMeta: pieceMetaSchema,
+  },
+};
+
+export const RosterLockV1SchemaKeywords = [
+  ...sharedKeywords,
+  ...engineKeywords,
+  ...rosterKeywords,
+  ...selectionKeywords,
+  ...pieceMetaKeywords,
+];
+
+
+export const ROSTERLOCK_V1_CASTER_JSONSCHEMA = new JSONSchemaCaster<
+  RosterLockV1Config
+>(RosterLockV1Schema,RosterLockV1SchemaKeywords);

package/src/match-lock-file/match-config/version-1/lock/piece-meta/caster-json-schema/index.ts

@@ -0,0 +1,97 @@
+
+import { JSONSchemaType } from "ajv";
+import { defineKeyword } from "../../../../../util-types/json-schema";
+import { RosterLockV1Config, SelectionPieceMeta, JSONShallowObject } from "@roster-lock/types";
+
+import { validateMetaDefaultValue, validateMetaForPiece } from "../validate";
+
+export const metaDefaultValueSchemaValidator = defineKeyword({
+  keyword: "metaDefaultValue",
+  type: "object",
+  validate: (defaultMeta: JSONShallowObject, { pieceMeta }: RosterLockV1Config, path)=>{
+    const pathParts = path.split("/");
+    // /pieceMeta/pieceType/defaultMeta
+    const pieceType = pathParts[2];
+    const sharedPieceMeta = pieceMeta[pieceType];
+    if(!sharedPieceMeta){
+      throw new Error(`Piece type ${pieceType} does not have shared piece meta`);
+    }
+    validateMetaDefaultValue(sharedPieceMeta.schema, defaultMeta);
+  },
+});
+
+
+export const metaPieceValueSchemaValidator = defineKeyword({
+  keyword: "metaPieceValue",
+  type: "object",
+  validate: (pieceValue: JSONShallowObject, { pieceMeta, rosters }: RosterLockV1Config, path)=>{
+    const pathParts = path.split("/");
+    // /pieceMeta/pieceType/values/pieceId
+    const pieceType = pathParts[2];
+    const pieceId = pathParts[4]?.replace(/~1/g, "/").replace(/~0/g, "~");
+    const sharedPieceMeta = pieceMeta[pieceType];
+    if(!sharedPieceMeta){
+      throw new Error(`Piece type ${pieceType} does not have shared piece meta`);
+    }
+    const roster = rosters[pieceType];
+    if(!roster){
+      throw new Error(`Piece type ${pieceType} does not have a roster`);
+    }
+    validateMetaForPiece(sharedPieceMeta.schema, pieceId, pieceValue, roster);
+  },
+});
+
+const shallowObjectSchema = {
+  type: "object",
+  required: [],
+  additionalProperties: {
+    anyOf: [
+      { type: "string" },
+      { type: "number" },
+      { type: "boolean" },
+      { type: "array", items: { type: "string" } },
+      { type: "array", items: { type: "number" } },
+      { type: "array", items: { type: "boolean" } },
+    ],
+  },
+} as const;
+
+
+export const selectionPieceMetaSchema: JSONSchemaType<SelectionPieceMeta<JSONShallowObject>> = {
+  type: "object",
+  required: ["schema","defaultMeta", "values"],
+  additionalProperties: false,
+  properties: {
+    schema: {
+      type: "object",
+      required: [],
+      additionalProperties: {
+        type: "string",
+        enum: ["boolean", "number", "string", "boolean[]", "number[]", "string[]"],
+      },
+    },
+    defaultMeta: {
+      ...shallowObjectSchema,
+      [metaDefaultValueSchemaValidator.keyword]: true,
+    },
+    values: {
+      type: "object",
+      required: [],
+      additionalProperties: {
+        ...shallowObjectSchema,
+        [metaPieceValueSchemaValidator.keyword]: true,
+      }
+    },
+  },
+};
+
+export const pieceMetaSchema: JSONSchemaType<RosterLockV1Config["pieceMeta"]> = {
+  type: "object",
+  required: [],
+  additionalProperties: selectionPieceMetaSchema,
+};
+
+export const pieceMetaKeywords = [
+  metaDefaultValueSchemaValidator,
+  metaPieceValueSchemaValidator,
+];

package/src/match-lock-file/match-config/version-1/lock/piece-meta/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./validate";
+export * from "./caster-json-schema";