Struct ForgeConfig 

pub struct ForgeConfig {

    pub prefix: String,
    pub token_ttl_secs: u64,
    pub max_body_bytes: usize,
    pub fetch_concurrency: usize,
    pub fetch_timeout_secs: u64,
    pub thread_cap: usize,
    pub default_chain: String,
    pub allow_mainnet: bool,
    pub announce_relays: Vec<String>,
    pub announce_key: Option<AnnounceKey>,
    pub anchoring_ui: bool,
    pub sparse_marks: bool,
    pub private_repos: bool,
    pub base_url: Option<String>,
    pub loopback_url: Option<String>,
    pub csp_connect: Vec<String>,
    pub open_edit: bool,
}

All tunables for a crate::ForgeService.

Fields

prefix: String

URL prefix the forge is mounted under (default /forge). No trailing slash.

token_ttl_secs: u64

Time-to-live for a minted forge push token, in seconds.

max_body_bytes: usize

Per-body byte cap when re-fetching pod-hosted issue/PR bodies (default 64 KiB).

fetch_concurrency: usize

Parallelism for the read-time body fetch (default 8).

fetch_timeout_secs: u64

Per-body fetch timeout, seconds (default 8).

thread_cap: usize

Hard cap on thread pointers materialised in one read (default 500).

default_chain: String

Bitcoin chain the mark trail targets. "tbtc4" (testnet4) by default; mainnet ("btc"/"mainnet") is refused unless ForgeConfig::allow_mainnet is set.

allow_mainnet: bool

Fail-closed mainnet guard. When false, Self::chain_allowed rejects any mainnet chain string. Mark custody here is testnet-grade.

announce_relays: Vec<String>

Opt-in relays the NIP-34 announcement is published to. Empty = build/sign only, never publish. Only ws:// and wss:// entries are used (JSS announceRelays).

announce_key: Option<AnnounceKey>

The forge-instance NIP-34 signing key (JSS announceKey): 32-byte hex. When unset or malformed the key persisted at plugin_dir/announce-key is used, generated once. Its Debug output is redacted.

anchoring_ui: bool

Show the Anchors tab on every repository page, not only on repositories that already carry a trail (JSS anchoringUi). The /marks page then carries the Enable pitch where anchoring is off. Default false. Needs the anchoring feature to link anywhere.

sparse_marks: bool

Sparse marking (JSS sparseMarks): a trailing unfunded mark is re-targeted at each new default-branch tip instead of stacking a new one, so anchoring HEAD costs one transaction however many commits landed. Default false.

private_repos: bool

JSS privateRepos: when true every read (git, HTML, JSON) is owner-only. Default false.

base_url: Option<String>

JSS baseUrl: public origin used for absolute clone and hosted-body URLs (reverse-proxy override). None falls back to the request’s host_url.

loopback_url: Option<String>

JSS loopbackUrl: origin of the host’s own HTTP surface for pod body reads. Informational for embedders that build a crate::LoopbackFetch; None means “derive it”.

csp_connect: Vec<String>

JSS cspConnect: extra http(s) origins admitted into the connect-src of the page CSP (see crate::xlogin::build_csp).

open_edit: bool

JSS openEdit: when true, the web-edit and preview endpoints (POST api/repos/<o>/<n>/edit and /preview) accept anonymous callers on any repository. Demo use only; default false, and crate::ForgeService::new logs a loud warning when it is on.

Implementations

impl ForgeConfig

pub fn normalized_prefix(&self) -> String

Normalise the configured prefix: ensure a single leading slash and no trailing slash. "" and "/" both normalise to "" (root mount).

pub fn chain_allowed(&self, chain: &str) -> bool

Is chain permitted under the current mainnet policy? Mainnet aliases are refused unless allow_mainnet.

pub fn validate_chain(&self) -> Result<(), ForgeError>

Check Self::default_chain the way JSS activate does, before any other work: a mainnet chain is an error unless allow_mainnet, and a chain with no known address prefix is an error too (no address beats a wrong-network address someone might fund).

Errors

ForgeError::BadRequest naming the stakes (MAINNET, allow_mainnet) or the unknown chain.

Examples

use solid_pod_rs_forge::ForgeConfig;

assert!(ForgeConfig::default().validate_chain().is_ok());
let mainnet = ForgeConfig { default_chain: "xbt".into(), ..Default::default() };
assert!(mainnet.validate_chain().unwrap_err().to_string().contains("MAINNET"));
let unknown = ForgeConfig { default_chain: "dogecoin".into(), ..Default::default() };
assert!(unknown.validate_chain().unwrap_err().to_string().contains("unknown"));

impl ForgeConfig

pub fn from_json(v: &Value) -> Self

Build a config from a JSON object in the JSS key spelling. Unknown keys are ignored; absent keys keep their Default.

Examples

use serde_json::json;
use solid_pod_rs_forge::ForgeConfig;

let c = ForgeConfig::from_json(&json!({"privateRepos": true, "baseUrl": "https://f.example/", "cspConnect": ["https://idp.example"]}));
assert!(c.private_repos);
assert_eq!(c.base_url.as_deref(), Some("https://f.example"));
assert_eq!(c.csp_connect, vec!["https://idp.example".to_string()]);

pub fn from_layers(explicit: Value, defaults_file: Option<&Path>) -> Self

Layer an optional defaults file under explicit and build the config. A missing or unreadable file only logs a warning (JSS behaviour).

pub fn from_env(explicit: Value) -> Self

from_layers with the file taken from the FORGE_CONFIG environment variable (unset or empty: no file).

pub fn public_origin(&self, fallback: Option<&str>) -> String

The public origin: base_url when configured, else fallback (typically the request’s host_url), without a trailing slash.

Trait Implementations

impl Clone for ForgeConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ForgeConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ForgeConfig

fn default() -> Self

Returns the “default value” for a type.