celerite 0.1.0-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d0d52428721b94c5ae1ff645216bda52f7893d98d4734ab6619d0590314be194
+  data.tar.gz: 7cdc50b2bedf79b1249091009406168d37cf80c34137c0792e82218a57cd5a34
+SHA512:
+  metadata.gz: a77706a8979485977038519a6f63dcf052b53e3b4dc352fc5c210dc5113bce34b05d0d45e29ddaffe41aa5b222edbf7eaf69c42a59637a66b84e5990dd0b2d6b
+  data.tar.gz: 8fbac8ee867f5c2977398815a8f9f4049baaebdae3405b7ff7ea32bc41854727d431446f262106ae50ca07380583290ded5234cb4f5f19c7b1257068cbb4f8de

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShiningRay <tsowly@hotmail.com>
+
+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,94 @@
+# Celerite
+
+A high-performance, Bundler-compatible Ruby dependency manager written in Crystal.
+
+> **Status: M0+M1 complete (read-only locked path).** Celerite reads lockfiles,
+> validates project state, and runs the locked-path versions of `check`,
+> `list`, `show`/`info`, `platform`, `lock --print`, and `config get` — all
+> verified byte-for-byte against pinned reference Bundlers via the differential
+> harness. Resolution, installation, and the Ruby bridge are next (M2+).
+> Compatibility is a release gate, not a claim based on parsing common Gemfiles.
+
+## Goals
+
+- Preserve Bundler's observable behavior: Gemfiles, lockfiles, CLI, installation,
+  runtime setup, and plugins.
+- Move dependency resolution, Compact Index processing, downloads, verification,
+  and installation planning into native Crystal code.
+- Keep a controlled Ruby compatibility bridge for arbitrary Ruby DSL, native
+  extension builds, and third-party Bundler plugins.
+- Verify behavior with differential tests and the upstream Bundler test suite.
+
+## Non-goals
+
+- Replacing Ruby or RubyGems.
+- Claiming compatibility through command names alone.
+- Silently delegating an entire installation to `bundle install` when native
+  functionality is missing.
+
+The `celerite` executable is the initial entry point. A `bundle` alias will be an
+explicit, opt-in installation step; it will never be overwritten automatically.
+
+## Documentation
+
+- [架构方案](docs/architecture.md)
+- [兼容性契约](docs/compatibility.md)
+- [实施计划](docs/roadmap.md)
+- [兼容矩阵基线](docs/compat-matrix/README.md) — per-version feature lists generated
+  from pinned upstream sources ([manifest](vendor/reference/MANIFEST.md))
+
+## Install
+
+One-liner (downloads the platform binary from GitHub Releases, verifies it
+against `checksums.sha256`, installs to `~/.local/bin`; never replaces an
+existing `bundle` — the shim lands as `celerite-bundle` instead):
+
+```console
+curl -fsSL https://github.com/ShiningRay/celerite/releases/latest/download/install.sh | bash
+```
+
+Options: `PREFIX=<dir>`, pin a version with an argument (`... | bash -s -- 0.1.0`).
+
+Via RubyGems (platform gems built per release):
+
+```console
+gem install celerite
+```
+
+The gem ships the native binary plus the Ruby bridge; the installed shim
+locates your Bundler gem automatically and exports the bridge environment
+(`CELERITE_BRIDGE_SERVER`, `CELERITE_REFERENCE_BUNDLER_LIB`,
+`CELERITE_PROFILE_BUNDLER_VERSION`).
+
+Darwin platform gems are self-contained: the release build bundles the
+non-system dylibs the binary links against (see `THIRD_PARTY_LICENSES.md`), so
+no Homebrew packages are required. Linux and Windows platform gems are built in
+CI but are not published until their dynamic-library bundling is verified; set
+the `CELERITE_PUSH_PLATFORM_GLOB` repository variable to widen the published
+platform set.
+
+Both channels are produced by `script/release` (dist bundle + platform gem
+with an install smoke test); releases are published from the `v*` tag
+workflow. A bare `gem build celerite.gemspec` produces a metadata-only gem —
+always build through `script/gem`.
+
+## Development
+
+Requires Crystal 1.21.1 or newer.
+
+```console
+shards build          # build bin/celerite
+crystal spec          # unit + property + behavior specs
+crystal tool format --check src spec
+script/differential   # differential harness vs pinned reference Bundlers
+```
+
+Reference Bundler versions (4.0.24 and 2.7.2) must be installed for the
+differential harness: `gem install bundler -v 4.0.24 -v 2.7.2`. The harness runs
+each fixture in isolated sandboxes (no network) and compares exit codes,
+stdout/stderr, and the project file tree after path normalization.
+
+## License
+
+MIT. Celerite is an independent project and is not affiliated with the Bundler
+or RubyGems teams.

data/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,21 @@
+# Third-party licenses
+
+Celerite itself is licensed under the MIT license (see `LICENSE`).
+
+The macOS platform gem bundles shared libraries that the native binary links
+against, so the gem runs on a machine without Homebrew packages installed. The
+corresponding license texts are shipped in `assets/licenses/`:
+
+| Library | License | Text |
+|---|---|---|
+| Boehm-Demers-Weiser GC (`libgc`) | MIT-style | `assets/licenses/bdw-gc.txt` |
+| OpenSSL (`libssl`, `libcrypto`) | Apache-2.0 | `assets/licenses/openssl.txt` |
+| PCRE2 (`libpcre2-8`) | BSD-3-Clause WITH PCRE2-exception | `assets/licenses/pcre2.txt` |
+| libyaml (`libyaml`) | MIT | `assets/licenses/libyaml.txt` |
+
+System libraries (`libSystem`, `libz`, `libiconv`) are provided by macOS and
+are not redistributed.
+
+Linux and Windows platform gems are built from the corresponding Crystal
+toolchain; their bundled libraries are recorded in the same directory when
+applicable.

data/assets/bridge/server.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+# Celerite Ruby compatibility bridge — JSON Lines server.
+#
+# Architecture contract (docs/architecture.md §2.2): a short-lived, controlled
+# Ruby subprocess implementing a versioned JSON Lines protocol. Each request
+# carries a protocol version, request id, op and payload; responses are either
+# structured results or structured errors — stderr/stdout Ruby text is never
+# parsed back.
+#
+# Protocol v1 request:  {"proto":1,"id":N,"op":"...","payload":{...}}
+# Protocol v1 response: {"proto":1,"id":N,"ok":true,"result":{...}}
+#                       {"proto":1,"id":N,"ok":false,"error":{"class":..,"message":..}}
+#
+# The bridge runs the Gemfile through the real Bundler::Dsl so arbitrary Ruby
+# DSL semantics match the reference exactly. Which Bundler is loaded is chosen
+# by the caller via $LOAD_PATH (CELERITE_REFERENCE_BUNDLER_LIB).
+
+require "json"
+require "digest"
+require "rbconfig"
+
+BRIDGE_PROTO = 1
+
+def bridge_emit(response)
+  $stdout.puts JSON.generate(response)
+  $stdout.flush
+end
+
+def bridge_error(id, klass, message)
+  bridge_emit("proto" => BRIDGE_PROTO, "id" => id, "ok" => false,
+              "error" => { "class" => klass, "message" => message })
+end
+
+def bridge_platform_string
+  require "rubygems/platform"
+  Gem::Platform.local.to_s
+end
+
+def op_ruby_environment(_payload)
+  require "rubygems"
+  {
+    "ruby_version" => RUBY_VERSION,
+    "ruby_description" => RUBY_DESCRIPTION,
+    "ruby_env_line" => "#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{Gem::Platform.local}]",
+    "engine" => RUBY_ENGINE,
+    "engine_version" => RUBY_ENGINE_VERSION,
+    "rubygems_version" => Gem::VERSION,
+    "ruby_revision" => RUBY_REVISION.to_s,
+    "platform" => bridge_platform_string,
+    "ruby_exe" => RbConfig.ruby,
+    "gem_paths" => (ENV["GEM_PATH"] ? ENV["GEM_PATH"].split(Gem.path_separator) : Gem.path),
+    "default_gem_dir" => (ENV["GEM_HOME"] || Gem.default_dir),
+    "user_gem_dir" => (Gem.user_dir rescue nil),
+    "loaded_bundler_version" => (defined?(Bundler) ? Bundler::VERSION : (Gem.loaded_specs["bundler"]&.version.to_s)),
+  }
+end
+
+# Loads Bundler from the requested load path (or whatever `ruby` resolves),
+# evaluates the Gemfile with the real Bundler::Dsl, and serializes the
+# evaluation results for the native core.
+def op_evaluate_gemfile(payload)
+  gemfile = payload["gemfile"]
+  raise ArgumentError, "missing gemfile path" unless gemfile
+
+  # Pin the reference Bundler when requested (isolated environments would
+  # otherwise fall back to the default gem). The load path wins because gem
+  # activation cannot see installed gems outside an isolated GEM_PATH.
+  if lib = ENV["CELERITE_REFERENCE_BUNDLER_LIB"]
+    $LOAD_PATH.unshift(lib) unless lib.empty?
+  elsif version = ENV["CELERITE_REFERENCE_BUNDLER_VERSION"]
+    gem "bundler", version unless version.empty?
+  end
+  require "bundler"
+  require "bundler/dsl"
+
+  builder = Bundler::Dsl.new
+  contents = File.read(gemfile)
+  builder.eval_gemfile(gemfile, contents)
+
+  deps = builder.dependencies.map do |dep|
+    source = dep.source
+    {
+      "name" => dep.name,
+      "requirements" => dep.requirement.as_list,
+      "groups" => dep.groups.map(&:to_s),
+      "platforms" => dep.platforms.map(&:to_s),
+      "autorequire" => dep.autorequire,
+      "force_ruby_platform" => dep.force_ruby_platform,
+      "gemspec_dev_dep" => !!dep.gemspec_dev_dep?,
+      "source" => source ? serialize_source(source) : nil,
+    }
+  end
+
+  {
+    "gemfile" => gemfile,
+    "dependencies" => deps,
+    "sources" => builder.instance_variable_get(:@sources).all_sources.map { |s| serialize_source(s) },
+    "ruby" => builder.instance_variable_get(:@ruby_version)&.to_s,
+    "bundler_version" => Bundler::VERSION,
+    "gemfile_sha256" => Digest::SHA256.hexdigest(contents),
+  }
+end
+
+def op_bundler_cache_file(payload)
+  require "bundler"
+  version = payload["version"]
+  version = Bundler::VERSION if version.nil? || version.empty?
+  spec = Gem::Specification.find_by_name("bundler", version)
+  { "path" => spec.cache_file, "exists" => File.exist?(spec.cache_file) }
+rescue Gem::LoadError, Gem::MissingSpecError, Gem::MissingSpecVersionError
+  # Isolated GEM_PATH: fall back to the load-path-provided gem (the running
+  # Bundler), matching how the reference's metadata source finds it.
+  if lib = ENV["CELERITE_REFERENCE_BUNDLER_LIB"]
+    # lib = <repository>/gems/bundler-<version>/lib; the spec cache file lives
+    # at <repository>/cache/bundler-<version>.gem
+    repository = File.expand_path("../../..", lib)
+    cache = File.join(repository, "cache", "bundler-#{version}.gem")
+    { "path" => cache, "exists" => File.exist?(cache), "lib_env" => lib }
+  else
+    { "path" => nil, "exists" => false }
+  end
+end
+
+# Unmarshal the specification of a .gem file and serialize the fields the
+# native installer needs (pinned: Gem::Package spec fields).
+def op_read_gem_spec(payload)
+  require "rubygems/package"
+  path = payload["path"]
+  spec = Gem::Package.new(path).spec
+  {
+    "name" => spec.name,
+    "version" => spec.version.to_s,
+    "platform" => spec.platform.to_s,
+    "full_name" => spec.full_name,
+    "executables" => spec.executables,
+    "bindir" => spec.bindir,
+    "required_ruby_version" => spec.required_ruby_version.to_s,
+    "required_rubygems_version" => spec.required_rubygems_version.to_s,
+    "extensions" => spec.extensions,
+    "date" => (spec.date.to_s if spec.respond_to?(:date)),
+    "license" => (spec.license if spec.respond_to?(:license)),
+    "licenses" => (spec.licenses if spec.respond_to?(:licenses)),
+    "dependencies" => spec.runtime_dependencies.map { |d|
+      { "name" => d.name, "type" => d.type.to_s, "requirements" => d.requirement.as_list }
+    },
+  }
+end
+
+# Write the Marshal'd specification of an installed gem (specifications/*.gemspec)
+# the way RubyGems does, given the extracted gem directory.
+def op_write_installed_spec(payload)
+  require "rubygems/package"
+  require "fileutils"
+  gem_path = payload["gem_path"]       # cache/<name>-<version>.gem
+  destination = payload["destination"] # specifications/<full_name>.gemspec
+  spec = Gem::Package.new(gem_path).spec
+  # Recording the install path keeps parity with RubyGems-installed specs
+  spec.full_gem_path = payload["gem_dir"] if payload["gem_dir"]
+  FileUtils.mkdir_p(File.dirname(destination))
+  # RubyGems writes Ruby-format stub specifications (not Marshal)
+  File.write(destination, spec.to_ruby_for_cache)
+  {
+    "name" => spec.name,
+    "full_name" => spec.full_name,
+    "executables" => spec.executables,
+    "bindir" => spec.bindir,
+    "extensions" => spec.extensions,
+  }
+end
+
+# Build native extensions with the reference Ruby/RubyGems toolchain
+# (architecture §2.1: extensions run through the Ruby toolchain, not native code).
+def op_build_extension(payload)
+  require "rubygems/ext"
+  require "rubygems/package"
+  require "rubygems/user_interaction"
+  require "fileutils"
+  # Builder output would corrupt the JSON Lines protocol on stdout; silence it
+  Gem::DefaultUserInteraction.ui = Gem::SilentUI.new
+  gem_dir = payload["gem_dir"]
+  destination = payload["destination"] # extensions/<platform>/<abi>/<full_name>
+  # The payload may not contain a .gemspec; load the spec from the cached .gem
+  spec = if payload["gem_path"] && File.exist?(payload["gem_path"])
+    Gem::Package.new(payload["gem_path"]).spec
+  else
+    Gem::Specification.load(File.join(gem_dir, "#{payload["name"]}.gemspec"))
+  end
+  raise "gemspec not found in #{gem_dir}" unless spec
+  gem_build_complete = File.join(destination, "gem.build_complete")
+  FileUtils.mkdir_p(destination)
+  spec.full_gem_path = gem_dir
+  spec.extension_dir = destination
+  Gem::Ext::Builder.new(spec).build_extensions
+  File.write(gem_build_complete, "")
+  { "built" => spec.extensions, "complete" => gem_build_complete }
+rescue StandardError => e
+  { "error" => e.message, "backtrace" => e.backtrace.first(4) }
+end
+
+# Load the gemspec of a directory source (path gems, git checkouts).
+def op_load_gemspec_dir(payload)
+  require "rubygems/specification"
+  dir = payload["dir"].tr("\\", "/")
+  glob = payload["glob"] || "{,*}.gemspec"
+  candidates = Dir.glob(File.join(dir, glob)).sort
+  raise "no gemspec in #{dir}" if candidates.empty?
+  spec = Gem::Specification.load(candidates.first)
+  raise "invalid gemspec in #{dir}" unless spec
+  {
+    "name" => spec.name,
+    "version" => spec.version.to_s,
+    "platform" => spec.platform.to_s,
+    "full_name" => spec.full_name,
+    "executables" => spec.executables,
+    "bindir" => spec.bindir,
+    "required_ruby_version" => spec.required_ruby_version.to_s,
+    "required_rubygems_version" => spec.required_rubygems_version.to_s,
+    "extensions" => spec.extensions,
+    "dependencies" => spec.runtime_dependencies.map { |d|
+      { "name" => d.name, "type" => d.type.to_s, "requirements" => d.requirement.as_list }
+    },
+  }
+end
+
+# Execute a plugin lifecycle hook through the reference Bundler::Plugin API
+# (architecture §2.2: plugin hooks are Ruby code, executed by the bridge).
+# payload: event, plugins_root (dir holding the plugins index), context (hash).
+def op_exec_plugin_hook(payload)
+  require "bundler"
+  require "bundler/plugin"
+  require "yaml"
+  event = payload["event"].to_s
+  index_path = payload["index_path"].to_s
+  return { "fired" => false, "reason" => "no plugin index" } unless File.exist?(index_path)
+
+  index = YAML.safe_load(File.read(index_path), permitted_classes: [Symbol], aliases: true) || {}
+  load_paths = index["load_paths"] || {}
+  hook_plugins = (index["hooks"] || {})[event] || []
+  return { "fired" => false, "reason" => "no plugins for event" } if hook_plugins.empty?
+
+  loaded = []
+  plugin_paths = index["plugin_paths"] || {}
+  hook_plugins.each do |name|
+    paths = load_paths[name]
+    if paths.is_a?(Array)
+      paths.each { |p| $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p) }
+    end
+    begin
+      # Reference entry point: each plugin ships a root plugins.rb
+      entry = plugin_paths[name] ? File.join(plugin_paths[name].to_s, "plugins.rb") : name.to_s.tr("-", "/")
+      require entry
+    rescue LoadError, StandardError => e
+      return { "fired" => false, "reason" => "plugin #{name} failed to load: #{e.message}" }
+    end
+    loaded << name
+  end
+
+  # plugins.rb (or its lib) registered hooks through the reference
+  # Bundler::Plugin::API (global registry). Bundler::Plugin.hook gates on
+  # its global index; for project-local plugins we invoke the registered
+  # blocks directly (same objects the reference would call).
+  hooks = Bundler::Plugin.instance_variable_get(:@hooks_by_event) || {}
+  blocks = hooks[event] || []
+  context = payload["context"] || {}
+  blocks.each { |blk| blk.call(context) }
+  { "fired" => blocks.any?, "plugins" => loaded }
+end
+
+def serialize_source(source)
+  type = source.class.name.split("::").last # Rubygems / Git / Path / Plugin / Metadata
+  result = { "type" => type }
+  if source.respond_to?(:remotes) && !source.remotes.empty?
+    result["remotes"] = source.remotes.map(&:to_s)
+  elsif source.respond_to?(:uri)
+    result["remote"] = source.uri.to_s
+  elsif source.respond_to?(:path) && source.path
+    # Path/Gemspec sources expose their location via #path
+    result["remote"] = source.path.to_s
+  end
+  %w[branch tag ref glob submodules].each do |key|
+    value = source.options[key] if source.respond_to?(:options)
+    result[key] = value if value
+  end
+  result
+end
+
+def bridge_dispatch(id, op, payload)
+  result = case op
+           when "ping"          then { "proto" => BRIDGE_PROTO, "ruby" => RUBY_VERSION }
+           when "ruby_environment" then op_ruby_environment(payload)
+           when "evaluate_gemfile" then op_evaluate_gemfile(payload)
+           when "bundler_cache_file" then op_bundler_cache_file(payload)
+           when "read_gem_spec" then op_read_gem_spec(payload)
+           when "write_installed_spec" then op_write_installed_spec(payload)
+           when "build_extension" then op_build_extension(payload)
+           when "load_gemspec_dir" then op_load_gemspec_dir(payload)
+           when "exec_plugin_hook" then op_exec_plugin_hook(payload)
+           else
+             return bridge_error(id, "UnknownOp", "unknown bridge op #{op.inspect}")
+           end
+  bridge_emit("proto" => BRIDGE_PROTO, "id" => id, "ok" => true, "result" => result)
+rescue Exception => e # rubocop:disable Lint/RescueException — bridge boundary: everything is reported, nothing escapes
+  bridge_error(id, e.class.name.to_s, e.message.to_s)
+end
+
+loop do
+  line = $stdin.gets
+  break if line.nil?
+
+  line = line.strip
+  next if line.empty?
+
+  request = JSON.parse(line)
+  id = request["id"]
+  unless request["proto"] == BRIDGE_PROTO
+    bridge_error(id, "ProtocolError", "unsupported proto #{request["proto"].inspect}")
+    next
+  end
+  bridge_dispatch(id, request["op"], request["payload"] || {})
+end

data/assets/licenses/bdw-gc.txt

@@ -0,0 +1,33 @@
+MIT-style License
+
+Copyright (c) 1988-1989 Hans-J. Boehm, Alan J. Demers
+Copyright (c) 1991-1996 by Xerox Corporation.  All rights reserved.
+Copyright (c) 1996-1999 by Silicon Graphics.  All rights reserved.
+Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
+Copyright (c) 1999-2001 by Red Hat, Inc.  All rights reserved.
+Copyright (c) 1999-2011 Hewlett-Packard Development Company, L.P.
+Copyright (c) 2004-2005 Andrei Polushin
+Copyright (c) 2007 Free Software Foundation, Inc.
+Copyright (c) 2008-2026 Ivan Maidanski
+Copyright (c) 2011 Ludovic Courtes
+Copyright (c) 2018 Petter A. Urkedal
+
+
+THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+
+Permission is hereby granted to use or copy this program
+for any purpose, provided the above notices are retained on all copies.
+Permission to modify the code and to distribute modified code is granted,
+provided the above notices are retained, and a notice that the code was
+modified is included with the above copyright notice.
+
+
+Several files (gc/gc_allocator.h, extra/msvc_dbg.c) come with slightly
+different licenses, though they are all similar in spirit (the exact
+licensing terms are given at the beginning of the corresponding source file).
+
+A few of the files needed to use the GNU-style build procedure come with
+a modified GPL license that appears not to significantly restrict use of
+the collector, though use of those files for a purpose other than building
+the collector may require the resulting code to be covered by the GPL.

data/assets/licenses/libyaml.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2017-2020 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+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/assets/licenses/openssl.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

data/assets/licenses/pcre2.txt

@@ -0,0 +1,104 @@
+PCRE2 Licence
+=============
+
+| SPDX-License-Identifier: | BSD-3-Clause WITH PCRE2-exception |
+|---------|-------|
+
+PCRE2 is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+Releases 10.00 and above of PCRE2 are distributed under the terms of the "BSD"
+licence, as specified below, with one exemption for certain binary
+redistributions. The documentation for PCRE2, supplied in the "doc" directory,
+is distributed under the same terms as the software itself. The data in the
+testdata directory is not copyrighted and is in the public domain.
+
+The basic library functions are written in C and are freestanding. Also
+included in the distribution is a just-in-time compiler that can be used to
+optimize pattern matching. This is an optional feature that can be omitted when
+the library is built. The just-in-time compiler is separately licensed under the
+"2-clause BSD" licence.
+
+
+COPYRIGHT
+---------
+
+### The basic library functions
+
+    Written by:       Philip Hazel
+    Email local part: Philip.Hazel
+    Email domain:     gmail.com
+
+    Retired from University of Cambridge Computing Service,
+    Cambridge, England.
+
+    Copyright (c) 1997-2007 University of Cambridge
+    Copyright (c) 2007-2024 Philip Hazel
+    All rights reserved.
+
+### PCRE2 Just-In-Time compilation support
+
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Email domain:     freemail.hu
+
+    Copyright (c) 2010-2024 Zoltan Herczeg
+    All rights reserved.
+
+### Stack-less Just-In-Time compiler
+
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Email domain:     freemail.hu
+
+    Copyright (c) 2009-2024 Zoltan Herczeg
+    All rights reserved.
+
+The code in the `deps/sljit` directory has its own LICENSE file.
+
+### All other contributions
+
+Many other contributors have participated in the authorship of PCRE2. As PCRE2
+has never required a Contributor Licensing Agreement, or other copyright
+assignment agreement, all contributions have copyright retained by each
+original contributor or their employer.
+
+
+THE "BSD" LICENCE
+-----------------
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notices,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notices, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of the University of Cambridge nor the names of any
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+EXEMPTION FOR BINARY LIBRARY-LIKE PACKAGES
+------------------------------------------
+
+The second condition in the BSD licence (covering binary redistributions) does
+not apply all the way down a chain of software. If binary package A includes
+PCRE2, it must respect the condition, but if package B is software that
+includes package A, the condition is not imposed on package B unless it uses
+PCRE2 independently.

data/exe/celerite

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Celerite gem shim (roadmap M6): dispatches to the platform binary shipped
+# in this gem and exports the bridge environment. The engine itself is the
+# native (Crystal) binary; nothing here reimplements Bundler behavior.
+#
+# Bridge env policy:
+# - CELERITE_BRIDGE_SERVER points at the server.rb inside this gem
+# - CELERITE_REFERENCE_BUNDLER_LIB / CELERITE_PROFILE_BUNDLER_VERSION are
+#   located from the user's installed Bundler gem (the engine needs the
+#   reference lib for gemspec evaluation and the public Ruby API)
+# - any explicit caller export wins over the shim's defaults
+
+require "rubygems/platform"
+
+gem_dir = File.expand_path("..", __dir__)
+lib_dir = File.join(gem_dir, "lib", "celerite")
+host = Gem::Platform.local
+
+binary = nil
+if Dir.exist?(lib_dir)
+  Dir.children(lib_dir).sort.each do |dir|
+    platform = begin
+      Gem::Platform.new(dir)
+    rescue ArgumentError
+      next
+    end
+    next unless platform === host
+    bin_name = %w[mingw mswin].include?(platform.os) ? "celerite.exe" : "celerite"
+    candidate = File.join(lib_dir, dir, bin_name)
+    if File.file?(candidate)
+      binary = candidate
+      break
+    end
+  end
+end
+
+abort "celerite: no shipped binary matches platform #{host}" unless binary
+
+bridge_env = {}
+bridge_env["CELERITE_BRIDGE_SERVER"] = File.join(gem_dir, "assets", "bridge", "server.rb")
+
+begin
+  require "rubygems/specification"
+  spec = Gem::Specification.find_by_name("bundler")
+  bridge_env["CELERITE_REFERENCE_BUNDLER_LIB"] = File.join(spec.full_gem_path, "lib")
+  bridge_env["CELERITE_PROFILE_BUNDLER_VERSION"] = spec.version.to_s
+rescue Gem::LoadError
+  # No Bundler installed: the engine falls back to its own resolution.
+end
+
+bridge_env.each do |key, value|
+  bridge_env.delete(key) if ENV[key] && !ENV[key].empty?
+end
+
+exec(bridge_env, binary, *ARGV)

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: celerite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: arm64-darwin
+authors:
+- ShiningRay
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'Celerite is a native (Crystal) engine for Bundler workflows: compact-index
+  resolution, lockfiles, checksummed installs, and the public Bundler Ruby API via
+  a compatibility bridge. Differential-tested against Bundler 4.0.24 and 2.7.2.'
+executables:
+- celerite
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- THIRD_PARTY_LICENSES.md
+- assets/bridge/server.rb
+- assets/licenses/bdw-gc.txt
+- assets/licenses/libyaml.txt
+- assets/licenses/openssl.txt
+- assets/licenses/pcre2.txt
+- exe/celerite
+- lib/celerite/arm64-darwin/celerite
+- lib/celerite/arm64-darwin/libcrypto.3.dylib
+- lib/celerite/arm64-darwin/libssl.3.dylib
+homepage: https://github.com/ShiningRay/celerite
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ShiningRay/celerite
+  bug_tracker_uri: https://github.com/ShiningRay/celerite/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: A high-performance, Bundler-compatible Ruby dependency manager
+test_files: []