APIs

Core

Pure helpers. They run in every language pack and in the hermetic Studio sandbox — no network, no disk.

JavaScript uses sirius.family.member. Tcl uses sirius::family::member. Go and WASM guests use a flat, idiomatic surface. The live catalog is GET /studio/sirius-api.

const body = sirius.json.decode(msg.raw);
body.site = sirius.text.upper(body.site || "");
body.processed_at = sirius.datetime.format(sirius.now(), "%Y-%m-%dT%H:%M:%S");
sirius.log.info("mapped " + body.site);
result = { message: body };

This page lists 74 symbols. The same catalog drives Studio autocomplete.

See also: Overview · Standards · I/O and runtime · Devices

`sirius.text`

Symbol	Signature	Returns	Summary
`sirius.text.capitalize`	`sirius.text.capitalize(s)`	string	capitalize
`sirius.text.contains`	`sirius.text.contains(s, sub)`	bool	substring test
`sirius.text.ends_with`	`sirius.text.ends_with(s, suffix)`	bool	suffix test
`sirius.text.format`	`sirius.text.format(template, args)`	string	expand a template with {} / {0} placeholders against args
`sirius.text.lower`	`sirius.text.lower(s)`	string	lower-case
`sirius.text.pad`	`sirius.text.pad(s, width, pad?, side?)`	string	pad to a fixed width (side left/right, default right)
`sirius.text.regex_replace`	`sirius.text.regex_replace(s, pattern, replacement)`	string	replace every RE2 match ($1/${name} in replacement)
`sirius.text.replace`	`sirius.text.replace(s, old, new)`	string	replace all occurrences
`sirius.text.split`	`sirius.text.split(s, sep)`	list of strings	split on a separator
`sirius.text.starts_with`	`sirius.text.starts_with(s, prefix)`	bool	prefix test
`sirius.text.substr`	`sirius.text.substr(s, start, length?)`	string	rune substring by start (negative = from end) and optional length
`sirius.text.trim`	`sirius.text.trim(s)`	string	trim surrounding whitespace
`sirius.text.upper`	`sirius.text.upper(s)`	string	upper-case

`sirius.json`

Symbol	Signature	Returns	Summary
`sirius.json.decode`	`sirius.json.decode(json)`	value	decode a JSON string
`sirius.json.encode`	`sirius.json.encode(value)`	json string	encode a value to JSON
`sirius.json.merge`	`sirius.json.merge(a, b)`	value	deep-merge two decoded values (b wins; objects recurse, arrays concat)
`sirius.json.path`	`sirius.json.path(value, path)`	value	resolve a dotted path (a.b[0].c) against a decoded value

`sirius.codec`

Symbol	Signature	Returns	Summary
`sirius.codec.base64_decode`	`sirius.codec.base64_decode(base64)`	bytes	base64 decode
`sirius.codec.base64_encode`	`sirius.codec.base64_encode(data)`	base64 string	base64 encode
`sirius.codec.bzip2_inflate`	`sirius.codec.bzip2_inflate(data)`	bytes	bzip2 inflate
`sirius.codec.gunzip`	`sirius.codec.gunzip(data)`	bytes	gzip inflate
`sirius.codec.gzip`	`sirius.codec.gzip(data)`	gzip bytes	gzip deflate
`sirius.codec.hex_decode`	`sirius.codec.hex_decode(hex)`	bytes	hex decode
`sirius.codec.hex_encode`	`sirius.codec.hex_encode(data)`	hex string	hex encode
`sirius.codec.html_escape`	`sirius.codec.html_escape(s)`	string	escape &<>’” for HTML/XML text
`sirius.codec.html_unescape`	`sirius.codec.html_unescape(s)`	string	reverse html_escape (resolves entities)
`sirius.codec.url_decode`	`sirius.codec.url_decode(s)`	string	reverse url_encode
`sirius.codec.url_encode`	`sirius.codec.url_encode(s)`	string	percent-encode for a URL query component
`sirius.codec.uu_decode`	`sirius.codec.uu_decode(data)`	bytes	uudecode
`sirius.codec.uu_encode`	`sirius.codec.uu_encode(data)`	string	uuencode
`sirius.codec.zlib_deflate`	`sirius.codec.zlib_deflate(data)`	zlib bytes	zlib deflate
`sirius.codec.zlib_inflate`	`sirius.codec.zlib_inflate(data)`	bytes	zlib inflate

`sirius.crypto`

Symbol	Signature	Returns	Summary
`sirius.crypto.aes_cbc_decrypt`	`sirius.crypto.aes_cbc_decrypt(key, iv, ciphertext)`	plaintext	AES-CBC decrypt
`sirius.crypto.aes_cbc_encrypt`	`sirius.crypto.aes_cbc_encrypt(key, iv, plaintext)`	ciphertext	AES-CBC encrypt
`sirius.crypto.aes_decrypt`	`sirius.crypto.aes_decrypt(key, blob, aad?)`	plaintext	AES-GCM decrypt
`sirius.crypto.aes_encrypt`	`sirius.crypto.aes_encrypt(key, plaintext, aad?)`	ciphertext	AES-GCM encrypt
`sirius.crypto.constant_time_equal`	`sirius.crypto.constant_time_equal(a, b)`	bool	constant-time string comparison (secrets/MACs/tokens)
`sirius.crypto.digest`	`sirius.crypto.digest(algo, data)`	hex string	hex digest
`sirius.crypto.hmac`	`sirius.crypto.hmac(algo, key, data)`	hex string	hex HMAC
`sirius.crypto.pbkdf2`	`sirius.crypto.pbkdf2(password, salt, iterations, keyLen, algo?)`	derived key	PBKDF2 key derivation
`sirius.crypto.random_bytes`	`sirius.crypto.random_bytes(n)`	base64 string	n cryptographically secure random bytes (base64)
`sirius.crypto.rsa_decrypt`	`sirius.crypto.rsa_decrypt(privatePem, ciphertext, algo?)`	plaintext	RSA-OAEP decrypt
`sirius.crypto.rsa_encrypt`	`sirius.crypto.rsa_encrypt(publicPem, plaintext, algo?)`	ciphertext	RSA-OAEP encrypt
`sirius.crypto.sign`	`sirius.crypto.sign(privatePem, algo, data)`	signature	RSA sign
`sirius.crypto.verify`	`sirius.crypto.verify(publicPem, algo, data, signature)`	bool	RSA verify

`sirius.datetime`

Symbol	Signature	Returns	Summary
`sirius.datetime.add`	`sirius.datetime.add(ts, unit, n)`	int (unix seconds)	shift a timestamp by n units (seconds/minutes/hours/days/weeks)
`sirius.datetime.diff`	`sirius.datetime.diff(a, b, unit)`	number	difference (a - b) expressed in a unit
`sirius.datetime.format`	`sirius.datetime.format(ts, format?, utc?)`	string	format a Unix timestamp (strftime)
`sirius.datetime.from_hl7`	`sirius.datetime.from_hl7(s)`	int (unix seconds)	parse an HL7 v2 timestamp to Unix seconds
`sirius.datetime.parse`	`sirius.datetime.parse(s, format?)`	int (unix seconds)	parse a timestamp to Unix seconds (auto-detect or strftime format)
`sirius.datetime.to_hl7`	`sirius.datetime.to_hl7(ts, utc?)`	string	format a timestamp as an HL7 v2 stamp (YYYYMMDDHHMMSS)

`sirius.date`

Symbol	Signature	Returns	Summary
`sirius.date`	`sirius.date(format, ts?, utc?)`	string	format a timestamp (strftime subset)

`sirius.now`

Symbol	Signature	Returns	Summary
`sirius.now`	`sirius.now()`	int (unix seconds)	current Unix time (whole seconds)

`sirius.clock`

Symbol	Signature	Returns	Summary
`sirius.clock`	`sirius.clock()`	float (seconds)	current wall-clock time (fractional seconds)

`sirius.time`

Symbol	Signature	Returns	Summary
`sirius.time.date`	`sirius.time.date(format, ts?)`	string	format a local timestamp
`sirius.time.difftime`	`sirius.time.difftime(a, b)`	number	difference between two timestamps
`sirius.time.gmdate`	`sirius.time.gmdate(format, ts?)`	string	format a UTC timestamp
`sirius.time.stamp`	`sirius.time.stamp()`	int	current Unix time

`sirius.log`

Symbol	Signature	Returns	Summary
`sirius.log.debug`	`sirius.log.debug(message)`	—	emit a debug log line
`sirius.log.error`	`sirius.log.error(message)`	—	emit an error log line
`sirius.log.info`	`sirius.log.info(message)`	—	emit an info log line
`sirius.log.warn`	`sirius.log.warn(message)`	—	emit a warning log line

`sirius.env`

Symbol	Signature	Returns	Summary
`sirius.env.get`	`sirius.env.get(name)`	string	read a scoped environment value
`sirius.env.has`	`sirius.env.has(name)`	bool	test presence of an environment key

`sirius.uuid`

Symbol	Signature	Returns	Summary
`sirius.uuid`	`sirius.uuid()`	string	random RFC 4122 v4 UUID

`sirius.hash`

Symbol	Signature	Returns	Summary
`sirius.hash`	`sirius.hash(algo, data)`	hex string	hex digest (md5/sha1/sha256/sha512)

`sirius.util`

Symbol	Signature	Returns	Summary
`sirius.util.guid`	`sirius.util.guid()`	string	random GUID (alias of sirius.uuid)
`sirius.util.md5`	`sirius.util.md5(s)`	hex string	hex MD5 digest

`sirius.xml`

Symbol	Signature	Returns	Summary
`sirius.xml.build`	`sirius.xml.build(spec)`	string (xml)	construct an XML element from a nested spec { tag, attrs?, text?, children? }
`sirius.xml.parse`	`sirius.xml.parse(raw)`	tree (map)	parse XML to a tree
`sirius.xml.xpath`	`sirius.xml.xpath(raw, expr)`	list of strings	evaluate a lightweight XPath subset (//tag, /a/b) → matching element texts
`sirius.xml.tree`	`sirius.xml.tree(raw)`	node	parse XML into a navigable node

`sirius.validate`

Symbol	Signature	Returns	Summary
`sirius.validate.hl7`	`sirius.validate.hl7(raw, required?)`	list of issues	validate HL7 v2 well-formedness + required segments
`sirius.validate.json`	`sirius.validate.json(value, schema)`	list of issues	validate a value against a minimal JSON-schema subset