openexit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25b31579dbf8907d27ac8b92f4c0dfad8ab692786e9be31e6a47571c47de1051
+  data.tar.gz: 99c48913267e0089fa03f4d5ee75907a2400be633660316967f94a431a223d13
+SHA512:
+  metadata.gz: 6cb48243a04cf9bac3e782dc73a7331642679dbbc4894488b08f4a9763b47ac2b8a4d59c267a0f72263b51f0ea4c083e3eb0634568e4345b20edad634e6142d1
+  data.tar.gz: d00467132dbc4878e98534457c1bb3e2e05c40ebd29919812b61a286e2fd40bd2fb5500269b8aba03b580905962c654d06c0cc1263b5ce0515844e492398dd01

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenExit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+# OpenExit
+
+> Portable state for any application.
+
+This gem implements PASP — the Portable Application State Protocol — for Ruby.
+
+Gem version: 0.1.0
+PASP protocol: 1.0

data/lib/openexit/bundle.rb

@@ -0,0 +1,98 @@
+require "json"
+module OpenExit
+  class Bundle
+    attr_reader :path
+    def initialize(path) = @path = File.expand_path(path.to_s)
+    def self.open(path) = new(path)
+    def inspect = OpenExit.inspect_bundle(path)
+    def verify = OpenExit.verify_bundle(path)
+  end
+  module BundleOps
+    module_function
+    def json_file(path, code)
+      JSON.parse(File.read(path, encoding: "UTF-8"))
+    rescue StandardError => e
+      raise PaspError.new(code, "invalid or missing JSON file: #{path}", context: e)
+    end
+    def lines(path, code)
+      return enum_for(__method__, path, code) unless block_given?
+      File.foreach(path, encoding: "UTF-8").with_index(1) do |line, number|
+        next if line.strip.empty?
+        begin value = JSON.parse(line); rescue JSON::ParserError => e; raise PaspError.new(code, "invalid NDJSON at #{path}:#{number}", context: e); end
+        yield number, value
+      end
+    rescue SystemCallError, EncodingError => e
+      raise PaspError.new(code, "cannot read NDJSON: #{path}", context: e)
+    end
+    def resource(root, entry, deep)
+      name = entry["name"]
+      descriptor_path = Paths.safe_path(root, entry["descriptor"])
+      descriptor = json_file(descriptor_path, "PASP_INVALID_RESOURCE")
+      Validation.validate_document("resource", descriptor, "PASP_INVALID_RESOURCE")
+      raise PaspError.new("PASP_INVALID_RESOURCE", "descriptor name mismatch") unless descriptor["name"] == name
+      schema = descriptor["schema"]
+      if schema.is_a?(String)
+        schema_path = Paths.safe_path(root, schema)
+        raise PaspError.new("PASP_MISSING_SCHEMA", "missing schema: #{schema}") unless File.file?(schema_path)
+        schema = json_file(schema_path, "PASP_MISSING_SCHEMA")
+      end
+      total = 0; chunks = []
+      descriptor.fetch("chunks").each_with_index do |raw, index|
+        expected = index + 1
+        expected_path = "resources/#{name}/%08d.ndjson" % expected
+        raise PaspError.new("PASP_INVALID_RESOURCE", "invalid chunk order/path") unless raw["sequence"] == expected && raw["path"] == expected_path
+        chunk_path = Paths.safe_path(root, raw["path"])
+        raise PaspError.new("PASP_INVALID_RESOURCE", "missing chunk") unless File.file?(chunk_path)
+        if deep
+          Integrity.verify_file(chunk_path, raw["sha256"], raw["uncompressedBytes"])
+          count = 0
+          lines(chunk_path, "PASP_INVALID_RECORD") do |line_no, record|
+            raise PaspError.new("PASP_INVALID_RECORD", "record is not an object") unless record.is_a?(Hash)
+            missing = Array(descriptor["identity"]).any? { |id| !record.key?(id) }
+            raise PaspError.new("PASP_INVALID_RECORD", "missing identity at line #{line_no}") if missing
+            count += 1
+          end
+          raise PaspError.new("PASP_INVALID_RESOURCE", "chunk record count mismatch") unless count == raw["recordCount"]
+        end
+        total += raw["recordCount"].to_i
+        chunks << Models::ResourceChunk.new(sequence: raw["sequence"], path: raw["path"], record_count: raw["recordCount"], uncompressed_bytes: raw["uncompressedBytes"], sha256: raw["sha256"])
+      end
+      raise PaspError.new("PASP_INVALID_RESOURCE", "resource record count mismatch") unless total == descriptor["recordCount"]
+      Models::Resource.new(name: name, schema: schema, identity: descriptor["identity"], record_count: descriptor["recordCount"], chunks: chunks, descriptor: entry["descriptor"])
+    end
+    def assets(root, raw, deep)
+      count = raw["count"].to_i; total = raw["totalBytes"].to_i; index = raw["index"]
+      return Models::AssetSummary.new(count: 0, total_bytes: 0, index: nil) if count == 0 && index.nil?
+      index_path = Paths.safe_path(root, index || "assets/index.ndjson")
+      raise PaspError.new("PASP_MISSING_ASSET", "missing asset index") unless File.file?(index_path)
+      seen = 0; bytes = 0
+      lines(index_path, "PASP_MISSING_ASSET") do |_n, asset|
+        Validation.validate_document("asset", asset, "PASP_MISSING_ASSET")
+        asset_path = Paths.safe_path(root, asset["path"])
+        raise PaspError.new("PASP_MISSING_ASSET", "missing asset") unless File.file?(asset_path)
+        Integrity.verify_file(asset_path, asset["sha256"], asset["byteLength"]) if deep
+        seen += 1; bytes += asset["byteLength"]
+      end
+      raise PaspError.new("PASP_MISSING_ASSET", "asset summary mismatch") unless seen == count && bytes == total
+      Models::AssetSummary.new(count: count, total_bytes: total, index: index)
+    end
+    def inspect_bundle(directory, deep)
+      root = File.expand_path(directory.to_s)
+      raise PaspError.new("PASP_MALFORMED_PACKAGE", "not a PASP directory") unless File.directory?(root)
+      manifest_path = Paths.safe_path(root, "manifest.json")
+      raise PaspError.new("PASP_MALFORMED_PACKAGE", "missing manifest.json") unless File.file?(manifest_path)
+      manifest = Manifest.parse(Pathname.new(manifest_path)); Validation.validate_manifest(manifest)
+      raw = manifest.raw; names = raw["resources"].map { |e| e["name"] }
+      resources = raw["resources"].map { |e| resource(root, e, deep) }
+      assets = assets(root, raw["assets"], deep)
+      relationships = 0
+      if raw["relationships"]
+        rels = json_file(Paths.safe_path(root, raw["relationships"]), "PASP_INVALID_RELATIONSHIP")
+        raise PaspError.new("PASP_INVALID_RELATIONSHIP", "relationships must be an array") unless rels.is_a?(Array)
+        rels.each { |rel| Validation.validate_document("relationship", rel, "PASP_INVALID_RELATIONSHIP"); raise PaspError.new("PASP_INVALID_RELATIONSHIP", "missing endpoint resource") unless names.include?(rel.dig("from", "resource")) && names.include?(rel.dig("to", "resource")) }
+        relationships = rels.length
+      end
+      Models::InspectionResult.new(valid: true, pasp_version: raw["paspVersion"], package_id: raw["packageId"], export_id: raw["exportId"], scope: Models::Scope.new(**raw["scope"].transform_keys(&:to_sym)), producer: Models::ProducerInfo.new(**raw["producer"].transform_keys(&:to_sym)), consistency: Models::Consistency.new(**raw["consistency"].transform_keys(&:to_sym)), resources: resources, assets: assets, relationships: relationships, integrity: Models::IntegrityInfo.new(**raw["integrity"].transform_keys(&:to_sym)))
+    end
+  end
+end

data/lib/openexit/constants.rb

@@ -0,0 +1,4 @@
+module OpenExit
+  SCHEMA_NAMES = %w[manifest scope resource resource-chunk asset relationship checkpoint event inspection-result].freeze
+  CONSISTENCY_LEVELS = %w[snapshot bounded best_effort].freeze
+end

data/lib/openexit/errors.rb

@@ -0,0 +1,11 @@
+module OpenExit
+  class Error < StandardError; end
+  class PaspError < Error
+    attr_reader :code, :context
+    def initialize(code, message, context: nil)
+      @code = code
+      @context = context
+      super(message)
+    end
+  end
+end

data/lib/openexit/integrity.rb

@@ -0,0 +1,20 @@
+require "digest"
+module OpenExit
+  module Integrity
+    module_function
+    def hash_file(path)
+      digest = Digest::SHA256.new
+      bytes = 0
+      File.open(path, "rb") { |io| while (chunk = io.read(1024 * 1024)); digest.update(chunk); bytes += chunk.bytesize; end }
+      [digest.hexdigest, bytes]
+    rescue SystemCallError => e
+      raise PaspError.new("PASP_MALFORMED_PACKAGE", "cannot read file: #{path}", context: e)
+    end
+    def verify_file(path, expected, expected_bytes = nil)
+      actual, bytes = hash_file(path)
+      raise PaspError.new("PASP_CHECKSUM_MISMATCH", "checksum mismatch: #{path}") unless actual == expected
+      raise PaspError.new("PASP_CHECKSUM_MISMATCH", "byte length mismatch: #{path}") if expected_bytes && bytes != expected_bytes
+      true
+    end
+  end
+end

data/lib/openexit/manifest.rb

@@ -0,0 +1,17 @@
+require "json"
+module OpenExit
+  module Manifest
+    module_function
+    def parse(source)
+      value = if source.is_a?(Hash) then source.dup
+      elsif source.respond_to?(:to_path) then JSON.parse(File.read(source.to_path, encoding: "UTF-8"))
+      elsif source.respond_to?(:read) then JSON.parse(source.read)
+      elsif source.is_a?(String) then JSON.parse(source)
+      else raise TypeError, "manifest source must be a Hash, path, IO, or JSON string" end
+      raise PaspError.new("PASP_INVALID_MANIFEST", "manifest must be a JSON object") unless value.is_a?(Hash)
+      Models::Manifest.new(value)
+    rescue JSON::ParserError, ArgumentError, EncodingError, Errno::ENOENT, IOError => e
+      raise PaspError.new("PASP_INVALID_MANIFEST", "cannot parse manifest JSON", context: e)
+    end
+  end
+end

data/lib/openexit/models.rb

@@ -0,0 +1,15 @@
+module OpenExit
+  module Models
+    Scope = Struct.new(:type, :id, :metadata, keyword_init: true)
+    ProducerInfo = Struct.new(:name, :version, keyword_init: true)
+    Consistency = Struct.new(:level, :metadata, keyword_init: true)
+    IntegrityInfo = Struct.new(:algorithm, :checksums, keyword_init: true)
+    ResourceChunk = Struct.new(:sequence, :path, :record_count, :uncompressed_bytes, :sha256, keyword_init: true)
+    Resource = Struct.new(:name, :schema, :identity, :record_count, :chunks, :descriptor, keyword_init: true)
+    AssetSummary = Struct.new(:count, :total_bytes, :index, keyword_init: true)
+    InspectionResult = Struct.new(:valid, :pasp_version, :package_id, :export_id, :scope, :producer, :consistency, :resources, :assets, :relationships, :integrity, keyword_init: true)
+    Manifest = Struct.new(:raw) do
+      def [](key) = raw[key.to_s] || raw[key.to_sym]
+    end
+  end
+end

data/lib/openexit/paths.rb

@@ -0,0 +1,23 @@
+module OpenExit
+  module Paths
+    module_function
+    def validate_package_path(value)
+      unless value.is_a?(String) && !value.empty? && !value.include?("\0") && !value.include?("\\") && !value.start_with?("/", "~") && value !~ /\A[A-Za-z]:/ && value.split("/").none? { |p| p.empty? || p == "." || p == ".." }
+        raise PaspError.new("PASP_PATH_TRAVERSAL", "unsafe package path: #{value}")
+      end
+      nil
+    end
+    def safe_path(root, value)
+      validate_package_path(value)
+      base = File.realpath(root)
+      candidate = File.expand_path(value.tr("/", File::SEPARATOR), base)
+      real = File.exist?(candidate) ? File.realpath(candidate) : candidate
+      unless real == base || real.start_with?(base + File::SEPARATOR)
+        raise PaspError.new("PASP_PATH_TRAVERSAL", "path escapes package: #{value}")
+      end
+      candidate
+    rescue Errno::ENOENT
+      candidate
+    end
+  end
+end

data/lib/openexit/schemas/asset.schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/asset.schema.json",
+  "title": "PASP Asset",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["id", "path", "sha256", "byteLength"],
+  "properties": {
+    "id": { "type": "string", "minLength": 1 },
+    "path": { "type": "string", "pattern": "^assets/objects/[A-Za-z0-9][A-Za-z0-9._/-]*$" },
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "byteLength": { "type": "integer", "minimum": 0 },
+    "name": { "type": "string" },
+    "mediaType": { "type": "string" },
+    "metadata": { "type": "object" }
+  }
+}

data/lib/openexit/schemas/checkpoint.schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/checkpoint.schema.json",
+  "title": "PASP Checkpoint",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["resource", "value"],
+  "properties": {
+    "resource": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" },
+    "value": {}
+  }
+}

data/lib/openexit/schemas/event.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/event.schema.json",
+  "title": "PASP Adapter Event",
+  "type": "object",
+  "required": ["type"],
+  "properties": {
+    "type": { "enum": ["export_begin", "resource_begin", "schema", "record", "checkpoint", "relationship", "asset", "resource_end", "export_end"] },
+    "scope": { "$ref": "scope.schema.json" },
+    "resource": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" },
+    "schema": { "type": "object" },
+    "schemaRef": { "type": "string" },
+    "value": {},
+    "relationship": { "$ref": "relationship.schema.json" },
+    "asset": { "$ref": "asset.schema.json" }
+  },
+  "allOf": [
+    { "if": { "properties": { "type": { "const": "export_begin" } } }, "then": { "required": ["scope"] } },
+    { "if": { "properties": { "type": { "enum": ["resource_begin", "resource_end", "schema", "record", "checkpoint"] } } }, "then": { "required": ["resource"] } },
+    { "if": { "properties": { "type": { "const": "record" } } }, "then": { "required": ["value"] } },
+    { "if": { "properties": { "type": { "const": "checkpoint" } } }, "then": { "required": ["value"] } },
+    { "if": { "properties": { "type": { "const": "relationship" } } }, "then": { "required": ["relationship"] } },
+    { "if": { "properties": { "type": { "const": "asset" } } }, "then": { "required": ["asset"] } }
+  ]
+}

data/lib/openexit/schemas/inspection-result.schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/inspection-result.schema.json",
+  "title": "PASP Inspection Result",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["valid", "paspVersion", "resources", "assets", "errors"],
+  "properties": {
+    "valid": { "type": "boolean" },
+    "paspVersion": { "type": "string" },
+    "resources": { "type": "integer", "minimum": 0 },
+    "assets": { "type": "integer", "minimum": 0 },
+    "errors": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["code", "message"], "properties": { "code": { "type": "string", "pattern": "^PASP_[A-Z0-9_]+$" }, "message": { "type": "string" }, "path": { "type": "string" } } } }
+  }
+}

data/lib/openexit/schemas/manifest.schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/manifest.schema.json",
+  "title": "PASP Manifest",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["format", "paspVersion", "packageId", "exportId", "createdAt", "producer", "scope", "consistency", "resources", "assets", "integrity"],
+  "properties": {
+    "format": { "const": "openexit.bundle" },
+    "paspVersion": { "const": "1.0" },
+    "packageId": { "type": "string", "minLength": 1 },
+    "exportId": { "type": "string", "minLength": 1 },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "producer": { "type": "object", "additionalProperties": false, "required": ["name", "version"], "properties": { "name": { "type": "string", "minLength": 1 }, "version": { "type": "string", "minLength": 1 } } },
+    "scope": { "$ref": "scope.schema.json" },
+    "consistency": { "type": "object", "additionalProperties": false, "required": ["level"], "properties": { "level": { "enum": ["snapshot", "bounded", "best_effort"] }, "metadata": { "type": "object" } } },
+    "resources": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "descriptor"], "properties": { "name": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" }, "descriptor": { "type": "string", "pattern": "^resources/[A-Za-z0-9][A-Za-z0-9._-]{0,127}/resource\\.json$" } } } },
+    "assets": { "type": "object", "additionalProperties": false, "required": ["count", "totalBytes"], "properties": { "count": { "type": "integer", "minimum": 0 }, "totalBytes": { "type": "integer", "minimum": 0 }, "index": { "type": "string", "const": "assets/index.ndjson" } } },
+    "integrity": { "type": "object", "additionalProperties": false, "required": ["algorithm"], "properties": { "algorithm": { "const": "sha256" }, "checksums": { "type": "string", "const": "checksums.sha256" } } },
+    "relationships": { "type": "string", "const": "relationships.json" }
+  }
+}

data/lib/openexit/schemas/relationship.schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/relationship.schema.json",
+  "title": "PASP Relationship",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["id", "from", "to", "cardinality"],
+  "properties": {
+    "id": { "type": "string", "minLength": 1 },
+    "from": { "$ref": "#/$defs/endpoint" },
+    "to": { "$ref": "#/$defs/endpoint" },
+    "cardinality": { "enum": ["one-to-one", "one-to-many", "many-to-one", "many-to-many", "reference"] },
+    "metadata": { "type": "object" }
+  },
+  "$defs": {
+    "endpoint": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["resource", "pointer"],
+      "properties": {
+        "resource": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" },
+        "pointer": { "type": "string", "pattern": "^(/([^/~]|~[01])*)*$" }
+      }
+    }
+  }
+}

data/lib/openexit/schemas/resource-chunk.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/resource-chunk.schema.json",
+  "title": "PASP Resource Chunk",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["sequence", "path", "recordCount", "uncompressedBytes", "sha256"],
+  "properties": {
+    "sequence": { "type": "integer", "minimum": 1 },
+    "path": { "type": "string", "pattern": "^resources/[A-Za-z0-9][A-Za-z0-9._-]{0,127}/[0-9]{8}\\.ndjson$" },
+    "recordCount": { "type": "integer", "minimum": 0 },
+    "uncompressedBytes": { "type": "integer", "minimum": 0 },
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "firstIdentity": {},
+    "lastIdentity": {},
+    "completedAt": { "type": "string", "format": "date-time" }
+  }
+}
+
+

data/lib/openexit/schemas/resource.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/resource.schema.json",
+  "title": "PASP Resource",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "schema", "identity", "recordCount", "chunks"],
+  "properties": {
+    "name": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" },
+    "schema": { "oneOf": [{ "type": "string", "pattern": "^schemas/[A-Za-z0-9._/-]+\\.schema\\.json$" }, { "type": "object" }] },
+    "schemaId": { "type": "string", "minLength": 1 },
+    "schemaVersion": { "type": "string", "minLength": 1 },
+    "identity": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 } },
+    "recordCount": { "type": "integer", "minimum": 0 },
+    "chunks": { "type": "array", "items": { "$ref": "resource-chunk.schema.json" } },
+    "ordered": { "type": "boolean" },
+    "metadata": { "type": "object" },
+    "capturedAt": { "type": "string", "format": "date-time" },
+    "snapshotToken": { "type": "string" }
+  }
+}

data/lib/openexit/schemas/scope.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://openexit.dev/pasp/1.0/schemas/scope.schema.json",
+  "title": "PASP Scope",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["type", "id"],
+  "properties": {
+    "type": { "type": "string", "minLength": 1 },
+    "id": { "type": "string", "minLength": 1 },
+    "metadata": { "type": "object" }
+  }
+}

data/lib/openexit/validation.rb

@@ -0,0 +1,48 @@
+require "json_schemer"
+require "json"
+module OpenExit
+  module Validation
+    module_function
+    def load_schema(name)
+      raise ArgumentError, "unknown PASP schema" unless SCHEMA_NAMES.include?(name)
+      JSON.parse(File.read(File.join(__dir__, "schemas", "#{name}.schema.json"), encoding: "UTF-8"))
+    end
+    def validate_manifest(manifest)
+      value = manifest.is_a?(Models::Manifest) ? manifest.raw : manifest
+      raise PaspError.new("PASP_INVALID_MANIFEST", "manifest must be an object") unless value.is_a?(Hash)
+      version = value["paspVersion"]
+      raise PaspError.new("PASP_UNSUPPORTED_VERSION", "unsupported PASP version: #{version}") if version && version != PASP_VERSION
+      required = %w[format paspVersion packageId exportId createdAt producer scope consistency resources assets integrity]
+      raise PaspError.new("PASP_INVALID_MANIFEST", "missing required manifest field") unless required.all? { |k| value.key?(k) }
+      raise PaspError.new("PASP_INVALID_MANIFEST", "invalid format") unless value["format"] == "openexit.bundle" && value["paspVersion"] == PASP_VERSION
+      raise PaspError.new("PASP_INVALID_MANIFEST", "invalid producer/scope/consistency") unless value["producer"].is_a?(Hash) && value["scope"].is_a?(Hash) && value["consistency"].is_a?(Hash)
+      raise PaspError.new("PASP_INVALID_MANIFEST", "invalid consistency") unless CONSISTENCY_LEVELS.include?(value.dig("consistency", "level"))
+      seen = {}
+      Array(value["resources"]).each do |entry|
+        name = entry.is_a?(Hash) && entry["name"]
+        raise PaspError.new("PASP_INVALID_RESOURCE", "invalid resource name") unless name.is_a?(String) && name.match?(/\A[A-Za-z0-9][A-Za-z0-9._-]{0,127}\z/)
+        raise PaspError.new("PASP_DUPLICATE_RESOURCE", "duplicate resource: #{name}") if seen[name]
+        seen[name] = true
+        descriptor = entry["descriptor"]
+        Paths.validate_package_path(descriptor)
+        raise PaspError.new("PASP_INVALID_MANIFEST", "invalid descriptor") unless descriptor == "resources/#{name}/resource.json"
+      end
+      true
+    rescue PaspError
+      raise
+    rescue StandardError => e
+      raise PaspError.new("PASP_INVALID_MANIFEST", "invalid manifest", context: e)
+    end
+    def validate_document(name, value, code)
+      case name
+      when "resource"
+        raise PaspError.new(code, "invalid resource") unless value.is_a?(Hash) && value["name"].is_a?(String) && value["schema"] && value["identity"].is_a?(Array) && value["recordCount"].is_a?(Integer) && value["chunks"].is_a?(Array)
+      when "asset"
+        raise PaspError.new(code, "invalid asset") unless value.is_a?(Hash) && value["id"].is_a?(String) && value["path"].is_a?(String) && value["sha256"].to_s.match?(/\A[a-f0-9]{64}\z/) && value["byteLength"].is_a?(Integer)
+      when "relationship"
+        raise PaspError.new(code, "invalid relationship") unless value.is_a?(Hash) && value["id"].is_a?(String) && %w[one-to-one one-to-many many-to-one many-to-many reference].include?(value["cardinality"]) && %w[from to].all? { |k| value[k].is_a?(Hash) && value[k]["resource"].is_a?(String) && value[k]["pointer"].is_a?(String) }
+      end
+      true
+    end
+  end
+end

data/lib/openexit/version.rb

@@ -0,0 +1,4 @@
+module OpenExit
+  VERSION = "0.1.0"
+  PASP_VERSION = "1.0"
+end

data/lib/openexit.rb

@@ -0,0 +1,20 @@
+require "pathname"
+require_relative "openexit/version"
+require_relative "openexit/constants"
+require_relative "openexit/errors"
+require_relative "openexit/models"
+require_relative "openexit/paths"
+require_relative "openexit/manifest"
+require_relative "openexit/validation"
+require_relative "openexit/integrity"
+require_relative "openexit/bundle"
+
+module OpenExit
+  class << self
+    def parse_manifest(source) = Manifest.parse(source)
+    def validate_manifest(manifest) = Validation.validate_manifest(manifest)
+    def inspect_bundle(path) = BundleOps.inspect_bundle(path, false)
+    def verify_bundle(path) = BundleOps.inspect_bundle(path, true)
+    def load_schema(name) = Validation.load_schema(name)
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: openexit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- OpenExit contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: Ruby SDK for reading and verifying Portable Application State Protocol
+  directory bundles.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/openexit.rb
+- lib/openexit/bundle.rb
+- lib/openexit/constants.rb
+- lib/openexit/errors.rb
+- lib/openexit/integrity.rb
+- lib/openexit/manifest.rb
+- lib/openexit/models.rb
+- lib/openexit/paths.rb
+- lib/openexit/schemas/asset.schema.json
+- lib/openexit/schemas/checkpoint.schema.json
+- lib/openexit/schemas/event.schema.json
+- lib/openexit/schemas/inspection-result.schema.json
+- lib/openexit/schemas/manifest.schema.json
+- lib/openexit/schemas/relationship.schema.json
+- lib/openexit/schemas/resource-chunk.schema.json
+- lib/openexit/schemas/resource.schema.json
+- lib/openexit/schemas/scope.schema.json
+- lib/openexit/validation.rb
+- lib/openexit/version.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: PASP 1.0 reader and verifier for Ruby
+test_files: []