@carrot-foundation/schemas 0.1.39 → 0.1.41

package/dist/index.cjs

@@ -5,14 +5,12 @@ require('fs');
 require('path');
 
 // src/mass-id/mass-id.attributes.ts
-var UuidSchema = zod.z.uuidv4("Must be a valid UUID v4 string").meta({
-  title: "UUID",
+var nativeDateParse = Date.parse.bind(Date);
+var ISO_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
+var UuidSchema = zod.z.uuidv4().meta({
+  title: "UUID V4",
   description: "A universally unique identifier version 4",
-  examples: [
-    "ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "6f520d88-864d-432d-bf9f-5c3166c4818f",
-    "f77afa89-1c58-40fd-9bf5-8a86703a8af4"
-  ]
+  examples: ["ad44dd3f-f176-4b98-bf78-5ee6e77d0530"]
 });
 var EthereumAddressSchema = zod.z.string().regex(
   /^0x[a-f0-9]{40}$/,
@@ -20,27 +18,33 @@ var EthereumAddressSchema = zod.z.string().regex(
 ).meta({
   title: "Ethereum Address",
   description: "A valid Ethereum address in hexadecimal format",
-  examples: [
-    "0x1234567890abcdef1234567890abcdef12345678",
-    "0xabcdef1234567890abcdef1234567890abcdef12"
-  ]
-});
-var IsoTimestampSchema = zod.z.iso.datetime({
-  message: "Must be a valid ISO 8601 timestamp with timezone"
+  examples: ["0x1234567890abcdef1234567890abcdef12345678"]
+});
+var IsoTimestampSchema = zod.z.string().regex(
+  ISO_TIMESTAMP_REGEX,
+  "Must be a valid ISO 8601 timestamp with timezone information"
+).superRefine((value, ctx) => {
+  const parsed = nativeDateParse(value);
+  if (Number.isNaN(parsed)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Must be a valid ISO 8601 timestamp with timezone information"
+    });
+  }
 }).meta({
   title: "ISO Timestamp",
   description: "ISO 8601 formatted timestamp with timezone information",
-  examples: ["2024-12-05T11:02:47.000Z", "2025-02-22T10:35:12.000Z"]
+  examples: ["2024-12-05T11:02:47.000Z"]
 });
 var IsoDateSchema = zod.z.iso.date("Must be a valid ISO 8601 date (YYYY-MM-DD)").meta({
   title: "ISO Date",
   description: "ISO 8601 formatted date in YYYY-MM-DD format",
-  examples: ["2024-12-05", "2025-02-22", "2024-02-10"]
+  examples: ["2024-12-05"]
 });
 var UnixTimestampSchema = zod.z.number().int().positive().meta({
   title: "Unix Timestamp",
   description: "Unix timestamp in milliseconds since epoch (January 1, 1970 00:00:00 UTC)",
-  examples: [17040672e5, 17356896e5, 1762371245149]
+  examples: [17040672e5]
 });
 var IsoCountryCodeSchema = zod.z.string().regex(/^[A-Z]{2}$/, "Must be a valid ISO 3166-1 alpha-2 country code").meta({
   title: "ISO Country Code",
@@ -57,15 +61,20 @@ var IsoAdministrativeDivisionCodeSchema = zod.z.string().regex(
 });
 var LatitudeSchema = zod.z.number().min(-90).max(90).multipleOf(1e-3).meta({
   title: "Latitude",
-  description: "Geographic latitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level, non-PII compliance)",
+  description: "Geographic latitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level)",
   examples: [-0.02, -20.38, 40.713]
 });
 var LongitudeSchema = zod.z.number().min(-180).max(180).multipleOf(1e-3).meta({
   title: "Longitude",
-  description: "Geographic longitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level, non-PII compliance)",
+  description: "Geographic longitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level)",
   examples: [-51.06, -40.34, -74.006]
 });
-var WeightKgSchema = zod.z.number().min(0).meta({
+var NonNegativeFloatSchema = zod.z.number().min(0).meta({
+  title: "Non-Negative Float",
+  description: "Floating-point number that is zero or positive",
+  examples: [0, 45.2, 72.5]
+});
+var WeightKgSchema = NonNegativeFloatSchema.meta({
   title: "Weight (kg)",
   description: "Weight measurement in kilograms",
   examples: [3e3, 1500, 500]
@@ -129,7 +138,7 @@ var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
 var WasteSubtypeSchema = NonEmptyStringSchema.max(100).meta({
   title: "Waste Subtype",
   description: "Specific subcategory of waste within a waste type",
-  examples: ["Food, Food Waste and Beverages", "PET Bottles", "Aluminum Cans"]
+  examples: ["Food, Food Waste and Beverages", "Domestic Sludge"]
 });
 var ParticipantRoleSchema = NonEmptyStringSchema.max(100).meta({
   title: "Participant Role",
@@ -141,29 +150,15 @@ var ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
   description: "Name of a participant in the waste management system",
   examples: ["Enlatados Produ\xE7\xE3o", "Eco Reciclagem", "Green Tech Corp"]
 });
-var FacilityTypeSchema = zod.z.enum([
-  "Collection Point",
-  "Recycling Facility",
-  "Administrative Office",
-  "Other"
-]).meta({
-  title: "Facility Type",
-  description: "Type of facility in the waste management chain",
-  examples: [
-    "Collection Point",
-    "Recycling Facility",
-    "Administrative Office"
-  ]
-});
-var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
+var BlockchainChainIdSchema = zod.z.union([zod.z.literal(137), zod.z.literal(80002)]).meta({
   title: "Chain ID",
-  description: "Blockchain network identifier",
-  examples: [1, 137, 11155111]
+  description: "Supported Polygon chain identifiers",
+  examples: [137, 80002]
 });
-var BlockchainNetworkNameSchema = NonEmptyStringSchema.max(100).meta({
+var BlockchainNetworkNameSchema = zod.z.enum(["Polygon", "Amoy"]).meta({
   title: "Blockchain Network Name",
-  description: "Name of the blockchain network",
-  examples: ["Polygon", "Ethereum mainnet", "Sepolia"]
+  description: "Supported Polygon network names",
+  examples: ["Polygon", "Amoy"]
 });
 var SmartContractAddressSchema = EthereumAddressSchema.meta({
   title: "Smart Contract Address",
@@ -177,7 +172,7 @@ var SmartContractSchema = zod.z.strictObject({
   title: "Smart Contract",
   description: "Smart contract details for on-chain references"
 });
-var PercentageSchema = zod.z.number().min(0).max(100).meta({
+var PercentageSchema = NonNegativeFloatSchema.max(100).meta({
   title: "Percentage",
   description: "Percentage value between 0 and 100",
   examples: [50, 75.5, 100]
@@ -192,11 +187,6 @@ var PositiveIntegerSchema = zod.z.number().int().min(1).meta({
   description: "Integer value that is greater than zero",
   examples: [1, 123, 456]
 });
-var NonNegativeFloatSchema = zod.z.number().min(0).meta({
-  title: "Non-Negative Float",
-  description: "Floating-point number that is zero or positive",
-  examples: [0, 45.2, 72.5]
-});
 var CreditTypeSchema = NonEmptyStringSchema.max(100).meta({
   title: "Credit Type",
   description: "Type of credit issued",
@@ -211,7 +201,7 @@ var HoursSchema = zod.z.number().min(0).multipleOf(0.1).meta({
   description: "Time duration in hours with 0.1 hour precision",
   examples: [72.5, 24, 168.5]
 });
-var MinutesSchema = zod.z.number().int().min(0).meta({
+var MinutesSchema = NonNegativeIntegerSchema.meta({
   title: "Minutes",
   description: "Time duration in minutes",
   examples: [4350, 1440, 10110]
@@ -241,7 +231,7 @@ var TokenIdSchema = NonEmptyStringSchema.regex(
 ).meta({
   title: "Token ID",
   description: "Numeric identifier for blockchain tokens as string",
-  examples: ["123", "456789", "1000000"]
+  examples: ["456789", "1000000"]
 });
 var HexColorSchema = NonEmptyStringSchema.regex(
   /^#[0-9A-F]{6}$/,
@@ -249,41 +239,28 @@ var HexColorSchema = NonEmptyStringSchema.regex(
 ).meta({
   title: "Hex Color",
   description: "Hexadecimal color code with hash prefix",
-  examples: ["#2D5A27", "#FF5733", "#1E90FF"]
+  examples: ["#2D5A27", "#FF5733"]
 });
 var Sha256HashSchema = zod.z.hash("sha256", {
-  error: "Must be a SHA256 hash as 32-byte hex string"
+  error: "Must be a SHA-256 hash as 32-byte hex string"
 }).meta({
   format: void 0,
-  title: "SHA256 Hash",
+  title: "SHA-256 Hash",
   description: "SHA-256 cryptographic hash as hexadecimal string",
   examples: [
-    "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489",
-    "6e83b8e6373847bbdc056549bedda38dc88854ce41ba4fca11e0fc6ce3e07ef6"
-  ]
-});
-var Keccak256HashSchema = Sha256HashSchema.meta({
-  title: "Keccak256 Hash",
-  description: "Keccak256 cryptographic hash as hexadecimal string",
-  examples: [
-    "ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f",
-    "b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2"
+    "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489"
   ]
 });
 var ExternalIdSchema = UuidSchema.meta({
   title: "External ID",
-  description: "UUID identifier for external system references",
-  examples: [
-    "ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "b2c4e6f8-a1b3-4c5d-9e8f-123456789abc"
-  ]
+  description: "UUID identifier for external system references"
 });
-var ExternalUrlSchema = zod.z.url("Must be a valid URL").meta({
+var ExternalUrlSchema = zod.z.url().meta({
   title: "External URL",
-  description: "Valid URL pointing to external resources",
+  description: "URL pointing to external resources",
   examples: [
-    "https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "https://carrot.eco/whitepaper.pdf"
+    "https://explore.carrot.eco/",
+    "https://https://whitepaper.carrot.eco/"
   ]
 });
 var RecordSchemaTypeSchema = zod.z.enum([
@@ -314,21 +291,6 @@ var CreditTokenSymbolSchema = TokenSymbolSchema.meta({
   description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
   examples: ["C-CARB", "C-BIOW"]
 });
-var RecordRelationshipTypeSchema = zod.z.enum([
-  "collection",
-  "credit",
-  "gas-id",
-  "mass-id",
-  "mass-id-audit",
-  "methodology",
-  "credit-purchase-receipt",
-  "credit-retirement-receipt",
-  "recycled-id"
-]).meta({
-  title: "Relationship Type",
-  description: "Type of relationship between different entities in the system",
-  examples: ["mass-id", "collection", "credit-purchase-receipt"]
-});
 function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
   return zod.z.array(schema).refine((items) => new Set(items).size === items.length, {
     message: errorMessage
@@ -367,10 +329,10 @@ var ParticipantSchema = zod.z.strictObject({
   title: "Participant",
   description: "A participant in the waste management supply chain"
 });
-var PrecisionLevelSchema = zod.z.enum(["exact", "neighborhood", "city", "region", "country"]).meta({
+var PrecisionLevelSchema = zod.z.enum(["city", "region", "country"]).meta({
   title: "Coordinate Precision Level",
   description: "Level of coordinate precision",
-  examples: ["city", "exact", "neighborhood"]
+  examples: ["city"]
 });
 var CoordinatesSchema = zod.z.strictObject({
   latitude: LatitudeSchema,
@@ -394,8 +356,7 @@ var LocationSchema = zod.z.strictObject({
     title: "Responsible Participant ID Hash",
     description: "Anonymized ID of the participant responsible for this location"
   }),
-  coordinates: CoordinatesSchema,
-  facility_type: FacilityTypeSchema.optional()
+  coordinates: CoordinatesSchema
 }).meta({
   title: "Location",
   description: "Geographic location with address and coordinate information"
@@ -613,70 +574,20 @@ var ParticipantRewardsSchema = zod.z.strictObject({
   title: "Participant Rewards",
   description: "Rewards distribution to participants"
 });
-var SchemaHashSchema = zod.z.union([
-  Keccak256HashSchema,
-  zod.z.string().regex(
-    /^0x[a-fA-F0-9]{64}$/,
-    "Must be a Keccak256 hash as 0x-prefixed hex string"
-  )
-]).meta({
+var SchemaHashSchema = Sha256HashSchema.meta({
   title: "Schema Hash",
-  description: "Keccak256 hash of the JSON Schema this record was validated against",
-  examples: [
-    "ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f",
-    "0xac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f"
-  ]
+  description: "SHA-256 hash of the JSON Schema this record was validated against"
 });
 var SchemaInfoSchema = zod.z.strictObject({
   hash: SchemaHashSchema,
-  type: RecordSchemaTypeSchema.meta({
-    title: "Schema Type",
-    description: "Type/category of this schema"
-  }),
+  type: RecordSchemaTypeSchema,
   version: SemanticVersionSchema.meta({
     title: "Schema Version",
     description: "Version of the schema, using semantic versioning"
   })
 }).meta({
-  title: "Schema Information"
-});
-var RecordCreatorSchema = zod.z.strictObject({
-  name: zod.z.string().meta({
-    title: "Creator Name",
-    description: "Company or individual name that created this record",
-    examples: ["Carrot Foundation"]
-  }),
-  id: UuidSchema.meta({
-    title: "Creator ID",
-    description: "Unique identifier for the creator"
-  })
-}).meta({
-  title: "Creator",
-  description: "Entity that created this record"
-});
-var RecordRelationshipSchema = zod.z.strictObject({
-  target_uri: IpfsUriSchema.meta({
-    title: "Target IPFS URI",
-    description: "Target IPFS URI of the referenced record"
-  }),
-  type: RecordRelationshipTypeSchema.meta({
-    title: "Relationship Type",
-    description: "Type of relationship to the referenced record"
-  }),
-  description: zod.z.string().optional().meta({
-    title: "Relationship Description",
-    description: "Human-readable description of the relationship",
-    examples: [
-      "This record supersedes the previous version",
-      "Related carbon credit batch",
-      "Source document for this verification",
-      "Child record derived from this parent",
-      "Updated version of original record"
-    ]
-  })
-}).meta({
-  title: "Relationship",
-  description: "Relationship to another IPFS record"
+  title: "Schema Information",
+  description: "Information about the schema used to validate this record"
 });
 var RecordEnvironmentSchema = zod.z.strictObject({
   blockchain_network: zod.z.enum(["mainnet", "testnet"]).meta({
@@ -692,8 +603,8 @@ var RecordEnvironmentSchema = zod.z.strictObject({
     description: "Name of the data set for this record"
   })
 }).meta({
-  title: "Environment",
-  description: "Environment information"
+  title: "Record Environment",
+  description: "Environment information for the record"
 });
 var BaseIpfsSchema = zod.z.strictObject({
   $schema: zod.z.url("Must be a valid URI").meta({
@@ -706,14 +617,8 @@ var BaseIpfsSchema = zod.z.strictObject({
     title: "Created At",
     description: "ISO 8601 creation timestamp for this record"
   }),
-  external_id: ExternalIdSchema.meta({
-    title: "External ID",
-    description: "Off-chain reference ID (UUID from Carrot backend)"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "External URL",
-    description: "External URL of the content"
-  }),
+  external_id: ExternalIdSchema,
+  external_url: ExternalUrlSchema,
   original_content_hash: Sha256HashSchema.meta({
     title: "Original Content Hash",
     description: "SHA-256 hash of the original JSON content including private data before schema validation"
@@ -722,11 +627,6 @@ var BaseIpfsSchema = zod.z.strictObject({
     title: "Content Hash",
     description: "SHA-256 hash of RFC 8785 canonicalized JSON after schema validation"
   }),
-  creator: RecordCreatorSchema.optional(),
-  relationships: zod.z.array(RecordRelationshipSchema).optional().meta({
-    title: "Relationships",
-    description: "References to other IPFS records this record relates to"
-  }),
   environment: RecordEnvironmentSchema.optional(),
   data: zod.z.record(zod.z.string(), zod.z.unknown()).optional().meta({
     title: "Custom Data",
@@ -736,6 +636,11 @@ var BaseIpfsSchema = zod.z.strictObject({
   title: "Base IPFS Record",
   description: "Base fields for all Carrot IPFS records, providing common structure for any JSON content stored in IPFS"
 });
+var BLOCKCHAIN_NETWORK_CONFIG = {
+  mainnet: { chain_id: 137, network_name: "Polygon" },
+  testnet: { chain_id: 80002, network_name: "Amoy" }
+};
+var ALLOWED_BLOCKCHAIN_NETWORKS = Object.values(BLOCKCHAIN_NETWORK_CONFIG);
 var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   "MassID",
   "RecycledID",
@@ -754,14 +659,27 @@ var BlockchainReferenceSchema = zod.z.strictObject({
     title: "Chain ID",
     description: "Blockchain chain ID"
   }),
-  network_name: zod.z.string().min(5).max(100).meta({
-    title: "Network Name",
-    description: "Name of the blockchain network"
-  }),
+  network_name: BlockchainNetworkNameSchema,
   token_id: TokenIdSchema.meta({
     title: "Token ID",
     description: "NFT token ID"
   })
+}).superRefine((value, ctx) => {
+  const matchedNetwork = ALLOWED_BLOCKCHAIN_NETWORKS.find(
+    (network) => network.chain_id === value.chain_id && network.network_name === value.network_name
+  );
+  if (!matchedNetwork) {
+    ctx.addIssue({
+      code: "custom",
+      message: "chain_id and network_name must match a supported network: 137/Polygon (mainnet) or 80002/Amoy (testnet)",
+      path: ["chain_id"]
+    });
+    ctx.addIssue({
+      code: "custom",
+      message: "chain_id and network_name must match a supported network: 137/Polygon (mainnet) or 80002/Amoy (testnet)",
+      path: ["network_name"]
+    });
+  }
 }).meta({
   title: "Blockchain Information",
   description: "Blockchain-specific information for the NFT"
@@ -906,6 +824,26 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
       ]
     ]
   })
+}).superRefine((value, ctx) => {
+  const environmentNetwork = value.environment?.blockchain_network;
+  if (!environmentNetwork) {
+    return;
+  }
+  const config = BLOCKCHAIN_NETWORK_CONFIG[environmentNetwork];
+  if (value.blockchain.chain_id !== config.chain_id) {
+    ctx.addIssue({
+      code: "custom",
+      message: `blockchain.chain_id must be ${config.chain_id} when environment.blockchain_network is ${environmentNetwork}`,
+      path: ["blockchain", "chain_id"]
+    });
+  }
+  if (value.blockchain.network_name !== config.network_name) {
+    ctx.addIssue({
+      code: "custom",
+      message: `blockchain.network_name must be ${config.network_name} when environment.blockchain_network is ${environmentNetwork}`,
+      path: ["blockchain", "network_name"]
+    });
+  }
 }).meta({
   title: "NFT IPFS Record",
   description: "NFT-specific fields for Carrot IPFS records"
@@ -918,7 +856,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.39";
+  return "0.1.41";
 }
 var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
@@ -1036,10 +974,6 @@ var AuditRuleDefinitionSchema = zod.z.strictObject({
       "https://github.com/carrot-foundation/methodologies/blob/main/bold-carbon/rules/waste-mass-unique.js"
     ]
   }),
-  mandatory: zod.z.boolean().meta({
-    title: "Mandatory",
-    description: "Whether this rule is mandatory for methodology compliance"
-  }),
   execution_order: PositiveIntegerSchema.meta({
     title: "Rule Execution Order",
     description: "Sequential order in which this rule must be executed"
@@ -1418,6 +1352,294 @@ function validateAttributesForItems(params) {
     }
   });
 }
+var IbamaWasteClassificationSchema = zod.z.string().regex(/^\d{2} \d{2} \d{2}\*?$/, "Invalid Ibama code format").meta({
+  title: "Ibama Classification Code",
+  description: "Ibama waste classification code in the format NN NN NN with required spaces and optional trailing *",
+  examples: ["20 01 01", "20 01 01*", "04 02 20"]
+});
+var MassIDLocalClassificationSchema = zod.z.strictObject({
+  code: IbamaWasteClassificationSchema,
+  system: zod.z.literal("Ibama").meta({
+    title: "Classification System",
+    description: "Authority or standard providing the classification code",
+    examples: ["Ibama"]
+  })
+}).meta({
+  title: "Local Classification",
+  description: "Regulatory classification reference for the waste material",
+  examples: [{ code: "04 02 20", system: "Ibama" }]
+});
+var MassIDWastePropertiesSchema = zod.z.strictObject({
+  type: WasteTypeSchema.meta({
+    title: "Waste Type",
+    description: "Waste material category",
+    examples: ["Organic"]
+  }),
+  subtype: WasteSubtypeSchema.meta({
+    title: "Waste Subtype",
+    description: "Specific subcategory of waste material",
+    examples: ["Food, Food Waste and Beverages"]
+  }),
+  local_classification: MassIDLocalClassificationSchema.optional(),
+  net_weight: WeightKgSchema.meta({
+    title: "Net Weight (kg)",
+    description: "Net weight of the waste batch in kilograms (kg)",
+    examples: [3e3]
+  })
+}).meta({
+  title: "Waste Properties",
+  description: "Standardized waste material properties and regulatory information"
+});
+var MassIDAttachmentTypeSchema = zod.z.enum(["Recycling Manifest", "Transport Manifest"]).meta({
+  title: "Attachment Type",
+  description: "Type of supporting attachment linked to a MassID event",
+  examples: ["Recycling Manifest", "Transport Manifest"]
+});
+var MassIDAttachmentSchema = zod.z.strictObject({
+  type: MassIDAttachmentTypeSchema,
+  document_number: NonEmptyStringSchema.max(50).optional().meta({
+    title: "Document Number",
+    description: "Official document number if applicable",
+    examples: ["2353", "12345"]
+  }),
+  issued_at: IsoTimestampSchema.optional().meta({
+    title: "Issued At",
+    description: "ISO 8601 timestamp when the attachment was issued"
+  }),
+  event_id: UuidSchema.meta({
+    title: "Event ID",
+    description: "Identifier of the event this attachment belongs to"
+  })
+}).meta({
+  title: "MassID Attachment",
+  description: "Attachment associated with a specific MassID event, linked by event_id"
+});
+var MassIDBaseEventSchema = zod.z.strictObject({
+  event_id: UuidSchema.meta({
+    title: "Event ID",
+    description: "Unique event identifier"
+  }),
+  description: NonEmptyStringSchema.max(200).optional().meta({
+    title: "Event Description",
+    description: "Detailed description of what happened during this event",
+    examples: [
+      "Waste collected from residential area using collection truck",
+      "Material sorted into recyclable and non-recyclable fractions",
+      "Waste transferred to authorized recycling facility"
+    ]
+  }),
+  timestamp: IsoTimestampSchema.meta({
+    title: "Event Timestamp",
+    description: "ISO 8601 timestamp when the event occurred"
+  }),
+  participant_id_hash: Sha256HashSchema.meta({
+    title: "Participant ID Hash",
+    description: "Reference to participant in the participants array"
+  }),
+  location_id_hash: Sha256HashSchema.meta({
+    title: "Location ID Hash",
+    description: "Reference to location in the locations array"
+  }),
+  weight: WeightKgSchema.optional().meta({
+    title: "Event Weight (kg)",
+    description: "Mass weight after this event in kilograms (kg)"
+  })
+}).meta({
+  title: "MassID Base Event",
+  description: "Base MassID event definition shared across event types"
+});
+var buildMassIDEventSchema = (eventName, description) => MassIDBaseEventSchema.safeExtend({
+  event_name: zod.z.literal(eventName).meta({
+    title: "Event Name",
+    description: `${eventName} event discriminator`,
+    examples: [eventName]
+  })
+}).meta({
+  title: `${eventName} Event`,
+  description
+});
+var PickUpEventSchema = buildMassIDEventSchema(
+  "Pick-up",
+  "Waste picked up from the origin location"
+).safeExtend({
+  data: zod.z.strictObject({
+    vehicle_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Vehicle Type",
+      description: "Type of vehicle used for pick-up operations",
+      examples: ["Truck", "Van", "Compactor"]
+    })
+  }).optional().meta({
+    title: "Pick-up Event Data",
+    description: "Vehicle information associated with the pick-up event"
+  })
+});
+var WeighingEventSchema = buildMassIDEventSchema(
+  "Weighing",
+  "Waste weighed at a facility"
+).safeExtend({
+  data: zod.z.strictObject({
+    weighing_capture_method: NonEmptyStringSchema.max(100).optional().meta({
+      title: "Weighing Capture Method",
+      description: "Method used to capture the weight measurement",
+      examples: [
+        "Digital scale integration",
+        "Manual entry",
+        "Automated capture via IoT scale"
+      ]
+    }),
+    scale_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Scale Type",
+      description: "Type of scale used to weigh the load",
+      examples: ["Weighbridge (Truck Scale)", "Axle scale"]
+    }),
+    container_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Container Type",
+      description: "Type of container holding the waste during weighing",
+      examples: ["Roll-off container", "Front loader bin"]
+    }),
+    vehicle_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Vehicle Type",
+      description: "Type of vehicle used during weighing",
+      examples: ["Truck", "Trailer"]
+    }),
+    container_capacity: WeightKgSchema.optional().meta({
+      title: "Container Capacity (kg)",
+      description: "Maximum container capacity in kilograms",
+      examples: [12e3]
+    }),
+    gross_weight: WeightKgSchema.optional().meta({
+      title: "Gross Weight (kg)",
+      description: "Total weight including vehicle/container before tare",
+      examples: [9500]
+    }),
+    tare: WeightKgSchema.optional().meta({
+      title: "Tare Weight (kg)",
+      description: "Weight of the empty vehicle or container",
+      examples: [3500]
+    })
+  }).optional().meta({
+    title: "Weighing Event Data",
+    description: "Weighing operational details including capture method, equipment, and weights"
+  })
+});
+var DropOffEventSchema = buildMassIDEventSchema(
+  "Drop-off",
+  "Waste delivered to a destination location"
+);
+var SortingEventSchema = buildMassIDEventSchema(
+  "Sorting",
+  "Sorting or segregation of waste materials"
+).safeExtend({
+  data: zod.z.strictObject({
+    initial_weight: WeightKgSchema.optional().meta({
+      title: "Initial Weight (kg)",
+      description: "Weight of the material entering the sorting process in kilograms",
+      examples: [5e3]
+    }),
+    deducted_weight: WeightKgSchema.optional().meta({
+      title: "Deducted Weight (kg)",
+      description: "Weight removed during sorting (e.g., contaminants or moisture) in kilograms",
+      examples: [250]
+    })
+  }).optional().meta({
+    title: "Sorting Event Data",
+    description: "Weights associated with sorting, including initial and deducted amounts"
+  })
+});
+var RecyclingEventSchema = buildMassIDEventSchema(
+  "Recycling",
+  "Waste processed or recycled at the destination"
+);
+var MassIDEventSchema = zod.z.discriminatedUnion("event_name", [
+  PickUpEventSchema,
+  WeighingEventSchema,
+  DropOffEventSchema,
+  SortingEventSchema,
+  RecyclingEventSchema
+]).meta({
+  title: "MassID Event",
+  description: "Lifecycle event describing custody, processing, documentation, or recycling steps"
+});
+var MassIDEventsSchema = zod.z.array(MassIDEventSchema).min(1).superRefine((events, ctx) => {
+  events.forEach((event, index) => {
+    if (index === 0) {
+      return;
+    }
+    const previousEvent = events[index - 1];
+    if (event.timestamp < previousEvent.timestamp) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "timestamp"],
+        message: "Events must be ordered by timestamp"
+      });
+    }
+  });
+}).meta({
+  title: "MassID Events",
+  description: "Chronological sequence of custody transfer, processing, and recycling events"
+});
+var MassIDDataSchema = zod.z.strictObject({
+  waste_properties: MassIDWastePropertiesSchema,
+  locations: uniqueBy(
+    LocationSchema,
+    (loc) => loc.id_hash,
+    "Location ID hashes must be unique"
+  ).min(1).meta({
+    title: "Locations",
+    description: "All locations referenced in this MassID, indexed by ID"
+  }),
+  participants: uniqueBy(
+    ParticipantSchema,
+    (participant) => participant.id_hash,
+    "Participant ID hashes must be unique"
+  ).min(1).meta({
+    title: "Participants",
+    description: "All participants referenced in this MassID, indexed by ID"
+  }),
+  events: MassIDEventsSchema,
+  attachments: zod.z.array(MassIDAttachmentSchema).optional().meta({
+    title: "Attachments",
+    description: "Supporting documents associated with events, linked by event_id"
+  })
+}).refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id_hash)
+  );
+  const eventParticipantIds = data.events.map(
+    (event) => event.participant_id_hash
+  );
+  const allEventParticipantsExist = eventParticipantIds.every(
+    (participantId) => participantIdSet.has(participantId)
+  );
+  return allEventParticipantsExist;
+}, "All participant ID hashes in events must exist in participants array").refine((data) => {
+  const locationIdSet = new Set(
+    data.locations.map((location) => location.id_hash)
+  );
+  const eventLocationIds = data.events.map((event) => event.location_id_hash);
+  const allEventLocationsExist = eventLocationIds.every(
+    (locationId) => locationIdSet.has(locationId)
+  );
+  return allEventLocationsExist;
+}, "All location ID hashes in events must exist in locations array").refine((data) => {
+  if (!data.attachments || data.attachments.length === 0) {
+    return true;
+  }
+  const eventIdSet = new Set(data.events.map((event) => event.event_id));
+  return data.attachments.every(
+    (attachment) => eventIdSet.has(attachment.event_id)
+  );
+}, "All attachments must reference an existing event by event_id").refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id_hash)
+  );
+  return data.locations.every(
+    (location) => participantIdSet.has(location.responsible_participant_id_hash)
+  );
+}, "All responsible participant ID hashes in locations must exist in participants array").meta({
+  title: "MassID Data",
+  description: "MassID data containing waste tracking events and supporting information"
+});
 
 // src/mass-id/mass-id.attributes.ts
 var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
@@ -1425,22 +1647,22 @@ var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
   value: WasteTypeSchema
 }).meta({
   title: "Waste Type Attribute",
-  description: "Waste type attribute"
+  description: "Primary waste material category (e.g., Organic, Paper, Glass, Metal)"
 });
 var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Subtype"),
   value: WasteSubtypeSchema
 }).meta({
   title: "Waste Subtype Attribute",
-  description: "Waste subtype attribute"
+  description: "Regulatory or operational waste subtype (e.g., Food, Food Waste and Beverages)"
 });
 var MassIDAttributeWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weight (kg)"),
   value: WeightKgSchema,
   display_type: zod.z.literal("number")
 }).meta({
-  title: "Weight Attribute",
-  description: "Weight attribute with numeric display"
+  title: "Weight Attribute (kg)",
+  description: "Net batch weight in kilograms (kg) for this MassID"
 });
 var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.safeExtend({
   value: CountryNameSchema
@@ -1453,84 +1675,70 @@ var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.safeExtend({
   value: AdministrativeDivisionSchema
 }).meta({
   title: "Origin Administrative Division Attribute",
-  description: "Origin administrative division attribute"
+  description: "State/province where the waste was generated (ISO 3166-2 preferred)"
 });
-var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Vehicle Type"),
+var MassIDAttributePickUpVehicleTypeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Pick-up Vehicle Type"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Vehicle Type",
-    description: "Type of vehicle used for waste transportation",
-    examples: ["Garbage Truck", "Box Truck", "Flatbed Truck", "Roll-off Truck"]
+    title: "Pick-up Vehicle Type",
+    description: "Type of vehicle used for waste pick-up operations",
+    examples: ["Truck", "Box Truck", "Flatbed Truck", "Roll-off Truck"]
   })
 }).meta({
-  title: "Vehicle Type Attribute",
-  description: "Vehicle type attribute"
+  title: "Pick-up Vehicle Type Attribute",
+  description: "Vehicle type used during pick-up"
 });
 var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Method",
     description: "Method used for recycling or processing the waste",
-    examples: [
-      "Composting",
-      "Mechanical Recycling",
-      "Incineration with Energy Recovery"
-    ]
+    examples: ["Composting", "Mechanical Recycling", "Anaerobic Digestion"]
   })
 }).meta({
   title: "Recycling Method Attribute",
-  description: "Recycling method attribute"
-});
-var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Processing Time (hours)"),
-  value: HoursSchema,
-  trait_description: NonEmptyStringSchema.max(200).optional().meta({
-    title: "Processing Time Description",
-    description: "Custom description for the processing time"
-  })
-}).meta({
-  title: "Processing Time Attribute",
-  description: "Processing time attribute with optional trait description"
+  description: "Process applied to this mass (e.g., composting, mechanical recycling)"
 });
 var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Local Waste Classification ID"),
-  value: NonEmptyStringSchema.max(100).meta({
-    title: "Local Waste Classification ID",
-    description: "Local or regional waste classification identifier",
-    examples: ["04 02 20", "IBAMA-A001", "EWC-150101"]
-  })
+  value: IbamaWasteClassificationSchema
 }).meta({
   title: "Local Waste Classification ID Attribute",
-  description: "Local waste classification ID attribute"
+  description: "Regulatory waste classification code (e.g., Ibama format NN NN NN[*])",
+  examples: ["20 01 01", "20 01 01*", "04 02 20"]
 });
 var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Recycling Manifest Code"),
+  trait_type: zod.z.literal("Recycling Manifest Number"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Recycling Manifest Code",
-    description: "Concatenated recycling manifest code (Document Type + Document Number)",
-    examples: ["CDF-2353", "RC-12345", "REC-MANIFEST-789"]
+    title: "Recycling Manifest Number",
+    description: "Official recycling manifest identifier",
+    examples: ["2353", "REC-MANIFEST-789", "RC12345"]
   })
 }).meta({
-  title: "Recycling Manifest Code Attribute",
-  description: "Recycling manifest code attribute (optional)"
+  title: "Recycling Manifest Number Attribute",
+  description: "Official recycling manifest number issued by recycling authority (optional)"
 });
 var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Transport Manifest Code"),
+  trait_type: zod.z.literal("Transport Manifest Number"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Transport Manifest Code",
-    description: "Concatenated transport manifest code (Document Type + Document Number)",
-    examples: ["MTR-4126", "TRN-67890", "TRANS-MANIFEST-456"]
+    title: "Transport Manifest Number",
+    description: "Official transport manifest identifier",
+    examples: ["4126", "TRN-67890", "TRANS-MANIFEST-456"]
   })
 }).meta({
-  title: "Transport Manifest Code Attribute",
-  description: "Transport manifest code attribute (optional)"
+  title: "Transport Manifest Number Attribute",
+  description: "Official transport manifest number issued by logistics/transport authority (optional)"
 });
 var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weighing Capture Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Weighing Capture Method",
     description: "Method used to capture weight data",
-    examples: ["Digital", "Manual", "Automated", "Electronic Scale"]
+    examples: [
+      "Digital scale integration",
+      "Manual entry",
+      "Automated capture via IoT scale"
+    ]
   })
 }).meta({
   title: "Weighing Capture Method Attribute",
@@ -1543,8 +1751,8 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
     description: "Type of scale used for weighing",
     examples: [
       "Weighbridge (Truck Scale)",
+      "Axle scale",
       "Floor Scale",
-      "Bench Scale",
       "Crane Scale"
     ]
   })
@@ -1552,35 +1760,36 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
   title: "Scale Type Attribute",
   description: "Scale type attribute (optional)"
 });
-var MassIDAttributeContainerTypeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Container Type"),
-  value: NonEmptyStringSchema.max(100).meta({
-    title: "Container Type",
-    description: "Type of container used for waste storage or transport",
-    examples: ["Truck", "Dumpster", "Roll-off Container", "Compactor", "Bin"]
-  })
-}).meta({
-  title: "Container Type Attribute",
-  description: "Container type attribute (optional)"
-});
 var MassIDAttributePickUpDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Pick-up Date"),
   value: UnixTimestampSchema.meta({
     title: "Pick-up Date",
     description: "Unix timestamp in milliseconds when the waste was picked up from the source",
-    examples: [17105184e5, 17040672e5, 17152704e5]
+    examples: [1733396567e3]
   }),
   display_type: zod.z.literal("date")
 }).meta({
   title: "Pick-up Date Attribute",
   description: "Pick-up date attribute with Unix timestamp"
 });
+var MassIDAttributeDropOffDateSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Drop-off Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Drop-off Date",
+    description: "Unix timestamp in milliseconds when the waste was dropped off at the destination",
+    examples: [1733407367e3]
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Drop-off Date Attribute",
+  description: "Drop-off date attribute with Unix timestamp"
+});
 var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "Recycling Date",
     description: "Unix timestamp in milliseconds when the waste was recycled/processed",
-    examples: [17106048e5, 17041536e5, 17153568e5]
+    examples: [1733657567e3]
   }),
   display_type: zod.z.literal("date")
 }).meta({
@@ -1595,308 +1804,24 @@ var MassIDAttributesSchema = uniqueBy(
     MassIDAttributeOriginCountrySchema,
     MassIDAttributeOriginMunicipalitySchema,
     MassIDAttributeOriginDivisionSchema,
-    MassIDAttributeVehicleTypeSchema,
+    MassIDAttributePickUpVehicleTypeSchema,
     MassIDAttributeRecyclingMethodSchema,
-    MassIDAttributeProcessingTimeSchema,
     MassIDAttributeLocalWasteClassificationIdSchema,
     MassIDAttributeRecyclingManifestCodeSchema,
     MassIDAttributeTransportManifestCodeSchema,
     MassIDAttributeWeighingCaptureMethodSchema,
     MassIDAttributeScaleTypeSchema,
-    MassIDAttributeContainerTypeSchema,
     MassIDAttributePickUpDateSchema,
+    MassIDAttributeDropOffDateSchema,
     MassIDAttributeRecyclingDateSchema
   ]),
   (attr) => attr.trait_type
-).min(12).max(17).meta({
+).min(11).max(16).meta({
   title: "MassID Attributes",
-  description: "MassID NFT attributes array containing attributes selected from the available attribute types. The schema validates array length but does not enforce which specific attributes must be present."
-});
-var MassIDLocalClassificationSchema = zod.z.strictObject({
-  code: NonEmptyStringSchema.max(20).meta({
-    title: "Classification Code",
-    description: "Local waste classification code",
-    examples: ["20 01 01", "D001", "EWC-150101", "IBAMA-A001"]
-  }),
-  description: NonEmptyStringSchema.max(200).meta({
-    title: "Classification Description",
-    description: "Local waste classification description",
-    examples: [
-      "Paper and cardboard packaging",
-      "Ignitable waste",
-      "Paper and cardboard packaging waste",
-      "Municipal solid waste - organic fraction"
-    ]
-  }),
-  system: zod.z.enum(["IBAMA"]).meta({
-    title: "Classification System",
-    description: "Classification system name - currently supports IBAMA (Instituto Brasileiro do Meio Ambiente e dos Recursos Naturais Renov\xE1veis)",
-    examples: ["IBAMA"]
-  })
-}).meta({
-  title: "Local Classification",
-  description: "Local or regional waste classification codes and descriptions"
-});
-var MassIDMeasurementUnitSchema = zod.z.enum(["kg", "ton"]).meta({
-  title: "Measurement Unit",
-  description: "Unit of measurement for the waste quantity",
-  examples: ["kg", "ton"]
-});
-var MassIDWastePropertiesSchema = zod.z.strictObject({
-  type: WasteTypeSchema.meta({
-    title: "Waste Type",
-    description: "Waste material category"
-  }),
-  subtype: WasteSubtypeSchema.meta({
-    title: "Waste Subtype",
-    description: "Specific subcategory of waste material"
-  }),
-  local_classification: MassIDLocalClassificationSchema.optional(),
-  measurement_unit: MassIDMeasurementUnitSchema,
-  net_weight: NonNegativeFloatSchema.meta({
-    title: "Net Weight",
-    description: "Net weight of the waste batch in the specified measurement unit"
-  })
-}).meta({
-  title: "Waste Properties",
-  description: "Standardized waste material properties and regulatory information"
-});
-var EventAttributeFormatSchema = zod.z.enum(["KILOGRAM", "DATE", "CURRENCY", "PERCENTAGE", "COORDINATE"]).meta({
-  title: "Event Attribute Format",
-  description: "Data format hint for proper display",
-  examples: ["KILOGRAM", "DATE", "PERCENTAGE"]
-});
-var EventAttributeSchema = zod.z.strictObject({
-  name: NonEmptyStringSchema.max(100).meta({
-    title: "Attribute Name",
-    description: "Event attribute name",
-    examples: [
-      "temperature",
-      "humidity",
-      "contamination_percentage",
-      "quality_grade",
-      "batch_number",
-      "operator_id",
-      "equipment_used",
-      "processing_cost"
-    ]
-  }),
-  value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).optional().meta({
-    title: "Attribute Value",
-    description: "Event attribute value",
-    examples: [
-      25.5,
-      "Grade A",
-      true,
-      "BATCH-2024-001",
-      12.75,
-      "Shredder-X200",
-      false,
-      "OP-456"
-    ]
-  }),
-  preserved_sensitivity: zod.z.boolean().optional().meta({
-    title: "Preserved Sensitivity",
-    description: "Indicates if the attribute contains sensitive information that was preserved"
-  }),
-  format: EventAttributeFormatSchema.optional()
-}).meta({
-  title: "Event Attribute",
-  description: "Additional attribute specific to an event"
-});
-var EventAttachmentSchema = zod.z.strictObject({
-  type: NonEmptyStringSchema.max(50).meta({
-    title: "Attachment Type",
-    description: "Type of supporting attachment",
-    examples: [
-      "Waste Transfer Note",
-      "Certificate of Disposal",
-      "Certificate of Final Destination",
-      "Quality Assessment Report",
-      "Transport Manifest",
-      "Processing Receipt",
-      "Environmental Permit",
-      "Invoice"
-    ]
-  }),
-  document_number: NonEmptyStringSchema.max(50).optional().meta({
-    title: "Document Number",
-    description: "Official document number if applicable",
-    examples: [
-      "WTN-2024-001234",
-      "CD-ENV-456789",
-      "INV-2024-QTR1-789",
-      "PERMIT-EPA-2024-001",
-      "MANIFEST-DOT-567890"
-    ]
-  }),
-  reference: NonEmptyStringSchema.meta({
-    title: "Attachment Reference",
-    description: "Reference to attachment (IPFS hash, file name, or external URL)",
-    examples: [
-      "QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o",
-      "waste_transfer_note_2024_001.pdf",
-      "https://docs.example.com/certificates/disposal_cert_456.pdf",
-      "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi",
-      "processing_receipt_20240315.jpg"
-    ]
-  }),
-  issue_timestamp: UnixTimestampSchema.optional().meta({
-    title: "Issue Timestamp",
-    description: "Unix timestamp in milliseconds when the attachment was issued",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  issuer: NonEmptyStringSchema.max(100).optional().meta({
-    title: "Attachment Issuer",
-    description: "Entity that issued the attachment",
-    examples: [
-      "Environmental Protection Agency",
-      "Waste Management Solutions Ltd",
-      "Green Recycling Corp",
-      "City Waste Authority",
-      "EcoProcess Industries",
-      "Regional Environmental Office"
-    ]
-  })
-}).meta({
-  title: "Event Attachment",
-  description: "Supporting event attachment"
-});
-var MassIDChainOfCustodyEventSchema = zod.z.strictObject({
-  event_id: UuidSchema.meta({
-    title: "Event ID",
-    description: "Unique event identifier"
-  }),
-  event_name: NonEmptyStringSchema.max(50).meta({
-    title: "Event Name",
-    description: "Name of custody or processing event",
-    examples: ["Sorting", "Processing", "Recycling", "Weighing"]
-  }),
-  description: NonEmptyStringSchema.max(200).optional().meta({
-    title: "Event Description",
-    description: "Detailed description of what happened during this event",
-    examples: [
-      "Waste collected from residential area using collection truck",
-      "Material sorted into recyclable and non-recyclable fractions",
-      "Plastic waste processed through shredding and washing",
-      "Waste transferred to authorized recycling facility",
-      "Final disposal at licensed landfill site",
-      "Quality inspection and contamination assessment completed"
-    ]
-  }),
-  timestamp: UnixTimestampSchema.meta({
-    title: "Event Timestamp",
-    description: "Unix timestamp in milliseconds when the event occurred",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  participant_id_hash: Sha256HashSchema.meta({
-    title: "Participant ID Hash",
-    description: "Reference to participant in the participants array"
-  }),
-  location_id_hash: Sha256HashSchema.meta({
-    title: "Location ID Hash",
-    description: "Reference to location in the locations array"
-  }),
-  weight: NonNegativeFloatSchema.optional().meta({
-    title: "Event Weight",
-    description: "Mass weight after this event"
-  }),
-  attributes: zod.z.array(EventAttributeSchema).optional().meta({
-    title: "Event Attributes",
-    description: "Additional attributes specific to this event"
-  }),
-  attachments: zod.z.array(EventAttachmentSchema).optional().meta({
-    title: "Event Attachments",
-    description: "Associated attachments for this event"
-  })
-}).meta({
-  title: "Chain of Custody Event",
-  description: "Chain of custody event"
-});
-var MassIDChainOfCustodySchema = zod.z.strictObject({
-  events: zod.z.array(MassIDChainOfCustodyEventSchema).min(1).meta({
-    title: "Custody Events",
-    description: "Chronological sequence of custody transfer and processing events"
-  }),
-  total_duration_minutes: MinutesSchema.meta({
-    title: "Total Duration (minutes)",
-    description: "Total time from first to last event in minutes"
-  })
-}).meta({
-  title: "Chain of Custody",
-  description: "Complete chain of custody tracking from waste generation to final processing"
-});
-var MassIDGeographicDataSchema = zod.z.strictObject({
-  from_location_id_hash: Sha256HashSchema.meta({
-    title: "From Location ID Hash",
-    description: "Reference hash of the location where the waste started movement"
-  }),
-  to_location_id_hash: Sha256HashSchema.meta({
-    title: "To Location ID Hash",
-    description: "Reference hash of the location where the waste ended movement"
-  }),
-  first_reported_timestamp: UnixTimestampSchema.meta({
-    title: "First Reported Timestamp",
-    description: "Unix timestamp in milliseconds when the waste was first reported/collected at the origin location",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  last_reported_timestamp: UnixTimestampSchema.meta({
-    title: "Last Reported Timestamp",
-    description: "Unix timestamp in milliseconds when the waste was last reported/processed at the destination location",
-    examples: [17106048e5, 17041536e5, 17153568e5]
-  })
-}).refine((data) => {
-  return data.first_reported_timestamp <= data.last_reported_timestamp;
-}, "first_reported_timestamp must be before or equal to last_reported_timestamp").meta({
-  title: "Geographic Data",
-  description: "Simplified geographic information tracking waste movement from origin to destination with temporal bounds"
-});
-var MassIDDataSchema = zod.z.strictObject({
-  waste_properties: MassIDWastePropertiesSchema,
-  locations: uniqueBy(
-    LocationSchema,
-    (loc) => loc.id_hash,
-    "Location ID hashes must be unique"
-  ).min(1).meta({
-    title: "Locations",
-    description: "All locations referenced in this MassID, indexed by ID"
-  }),
-  participants: uniqueBy(
-    ParticipantSchema,
-    (p) => p.id_hash,
-    "Participant ID hashes must be unique"
-  ).min(1).meta({
-    title: "Participants",
-    description: "All participants referenced in this MassID, indexed by ID"
-  }),
-  chain_of_custody: MassIDChainOfCustodySchema,
-  geographic_data: MassIDGeographicDataSchema
-}).refine((data) => {
-  const participantIdSet = new Set(
-    data.participants.map((participant) => participant.id_hash)
-  );
-  const eventParticipantIds = data.chain_of_custody.events.map(
-    (event) => event.participant_id_hash
-  );
-  const allEventParticipantsExist = eventParticipantIds.every(
-    (participantId) => participantIdSet.has(participantId)
-  );
-  return allEventParticipantsExist;
-}, "All participant ID hashes in chain of custody events must exist in participants array").refine((data) => {
-  const locationIdSet = new Set(
-    data.locations.map((location) => location.id_hash)
-  );
-  const eventLocationIds = data.chain_of_custody.events.map(
-    (event) => event.location_id_hash
-  );
-  const allEventLocationsExist = eventLocationIds.every(
-    (locationId) => locationIdSet.has(locationId)
-  );
-  return allEventLocationsExist;
-}, "All location ID hashes in chain of custody events must exist in locations array").meta({
-  title: "MassID Data",
-  description: "MassID data containing waste tracking and chain of custody information"
+  description: "MassID NFT attributes array. Provide the canonical set covering waste (type, subtype, net weight), origin (country, municipality, administrative division), logistics (vehicle, manifests, weighing method/scale), and lifecycle timestamps (pick-up, drop-off, recycling). Length is validated; specific composition is producer-controlled."
 });
+var isPickUpEvent = (event) => event.event_name === "Pick-up";
+var isWeighingEvent = (event) => event.event_name === "Weighing";
 var MassIDIpfsSchemaMeta = {
   title: "MassID NFT IPFS Record",
   description: "Complete MassID NFT IPFS record including fixed attributes and detailed waste tracking data",
@@ -1912,6 +1837,148 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   }),
   attributes: MassIDAttributesSchema,
   data: MassIDDataSchema
+}).superRefine((record, ctx) => {
+  const { data, attributes } = record;
+  const findAttribute = (traitType) => {
+    const index = attributes.findIndex(
+      (attribute) => attribute.trait_type === traitType
+    );
+    return {
+      attribute: index >= 0 ? attributes[index] : void 0,
+      index
+    };
+  };
+  const assertAttributeMatches = (traitType, expectedValue, sourceDescription) => {
+    const { attribute, index } = findAttribute(traitType);
+    if (expectedValue === void 0 || expectedValue === null) {
+      if (attribute) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["attributes", index],
+          message: `${traitType} attribute must be omitted when ${sourceDescription} is not provided`
+        });
+      }
+      return;
+    }
+    if (!attribute) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["attributes"],
+        message: `${traitType} attribute must be present and match ${sourceDescription}`
+      });
+      return;
+    }
+    if (attribute.value !== expectedValue) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["attributes", index, "value"],
+        message: `${traitType} attribute must equal ${sourceDescription}`
+      });
+    }
+  };
+  const assertTimestampAttributeMatches = (traitType, isoTimestamp, sourceDescription) => {
+    if (!isoTimestamp) {
+      assertAttributeMatches(traitType, void 0, sourceDescription);
+      return;
+    }
+    const timestamp = Date.parse(isoTimestamp);
+    if (Number.isNaN(timestamp)) {
+      return;
+    }
+    assertAttributeMatches(traitType, timestamp, sourceDescription);
+  };
+  assertAttributeMatches(
+    "Waste Type",
+    data.waste_properties.type,
+    "waste_properties.type"
+  );
+  assertAttributeMatches(
+    "Waste Subtype",
+    data.waste_properties.subtype,
+    "waste_properties.subtype"
+  );
+  assertAttributeMatches(
+    "Weight (kg)",
+    data.waste_properties.net_weight,
+    "waste_properties.net_weight"
+  );
+  assertAttributeMatches(
+    "Local Waste Classification ID",
+    data.waste_properties.local_classification?.code,
+    "waste_properties.local_classification.code"
+  );
+  const pickUpEvent = data.events.find(isPickUpEvent);
+  const pickUpLocation = pickUpEvent ? data.locations.find(
+    (location) => location.id_hash === pickUpEvent.location_id_hash
+  ) : void 0;
+  assertAttributeMatches(
+    "Origin Country",
+    pickUpLocation?.country,
+    "Pick-up event location.country"
+  );
+  assertAttributeMatches(
+    "Origin Municipality",
+    pickUpLocation?.municipality,
+    "Pick-up event location.municipality"
+  );
+  assertAttributeMatches(
+    "Origin Administrative Division",
+    pickUpLocation?.administrative_division,
+    "Pick-up event location.administrative_division"
+  );
+  assertTimestampAttributeMatches(
+    "Pick-up Date",
+    pickUpEvent?.timestamp,
+    "Pick-up event timestamp"
+  );
+  assertAttributeMatches(
+    "Pick-up Vehicle Type",
+    pickUpEvent?.data?.vehicle_type,
+    "Pick-up event vehicle_type"
+  );
+  const dropOffEvent = data.events.find(
+    (event) => event.event_name === "Drop-off"
+  );
+  assertTimestampAttributeMatches(
+    "Drop-off Date",
+    dropOffEvent?.timestamp,
+    "Drop-off event timestamp"
+  );
+  const recyclingEvent = data.events.find(
+    (event) => event.event_name === "Recycling"
+  );
+  assertTimestampAttributeMatches(
+    "Recycling Date",
+    recyclingEvent?.timestamp,
+    "Recycling event timestamp"
+  );
+  const weighingEvent = data.events.find(isWeighingEvent);
+  assertAttributeMatches(
+    "Weighing Capture Method",
+    weighingEvent?.data?.weighing_capture_method,
+    "Weighing event weighing_capture_method"
+  );
+  assertAttributeMatches(
+    "Scale Type",
+    weighingEvent?.data?.scale_type,
+    "Weighing event scale_type"
+  );
+  const recyclingManifest = data.attachments?.find(
+    (attachment) => attachment.type === "Recycling Manifest" && attachment.document_number
+  );
+  assertAttributeMatches(
+    "Recycling Manifest Number",
+    recyclingManifest?.document_number,
+    "Recycling Manifest attachment document_number"
+  );
+  const transportManifest = data.attachments?.find(
+    (attachment) => attachment.type === "Transport Manifest" && attachment.document_number
+  );
+  assertAttributeMatches(
+    "Transport Manifest Number",
+    transportManifest?.document_number,
+    "Transport Manifest attachment document_number"
+  );
 }).meta(MassIDIpfsSchemaMeta);
 var GasIDAttributeMethodologySchema = MethodologyAttributeSchema;
 var GasIDAttributeGasTypeSchema = NftAttributeSchema.safeExtend({
@@ -3431,7 +3498,6 @@ exports.EPSILON = EPSILON;
 exports.EthereumAddressSchema = EthereumAddressSchema;
 exports.ExternalIdSchema = ExternalIdSchema;
 exports.ExternalUrlSchema = ExternalUrlSchema;
-exports.FacilityTypeSchema = FacilityTypeSchema;
 exports.GasIDAttributesSchema = GasIDAttributesSchema;
 exports.GasIDDataSchema = GasIDDataSchema;
 exports.GasIDIpfsSchema = GasIDIpfsSchema;
@@ -3439,12 +3505,12 @@ exports.GasIDIpfsSchemaMeta = GasIDIpfsSchemaMeta;
 exports.GasIDReferenceSchema = GasIDReferenceSchema;
 exports.HexColorSchema = HexColorSchema;
 exports.HoursSchema = HoursSchema;
+exports.IbamaWasteClassificationSchema = IbamaWasteClassificationSchema;
 exports.IpfsUriSchema = IpfsUriSchema;
 exports.IsoAdministrativeDivisionCodeSchema = IsoAdministrativeDivisionCodeSchema;
 exports.IsoCountryCodeSchema = IsoCountryCodeSchema;
 exports.IsoDateSchema = IsoDateSchema;
 exports.IsoTimestampSchema = IsoTimestampSchema;
-exports.Keccak256HashSchema = Keccak256HashSchema;
 exports.LatitudeSchema = LatitudeSchema;
 exports.LocationSchema = LocationSchema;
 exports.LongitudeSchema = LongitudeSchema;
@@ -3483,7 +3549,6 @@ exports.PercentageSchema = PercentageSchema;
 exports.PositiveIntegerSchema = PositiveIntegerSchema;
 exports.ReceiptIdentitySchema = ReceiptIdentitySchema;
 exports.RecordEnvironmentSchema = RecordEnvironmentSchema;
-exports.RecordRelationshipTypeSchema = RecordRelationshipTypeSchema;
 exports.RecordSchemaTypeSchema = RecordSchemaTypeSchema;
 exports.RecycledIDAttributesSchema = RecycledIDAttributesSchema;
 exports.RecycledIDDataSchema = RecycledIDDataSchema;