Packages

A package is Jiang’s project boundary. A directory with package.ini can be compiled from its package root, and the compiler follows the reachable source dependency closure.

Package Manifest

Use a fixed package.ini file:

[package]
name = app
version = 1.0.0
root = src/main.jiang
type = bin

Fields:

• name: package name; defaults to the directory name.
• version: package version; optional. The compiler accepts ASCII letters, digits, ., _, +, and -.
• root: entry source file; defaults to <name>.jiang.
• type: package kind; defaults to an ordinary package. lang marks a custom-syntax provider package.

When the compiler input is a directory, it reads package.ini and compiles the source file named by root.

Dependencies

Declare local source dependencies in [dependencies]:

[package]
name = app
version = 1.0.0
root = src/main.jiang

[dependencies]
util = ../util

Inside the package, import a dependency by alias:

import util;

Int main() {
    return util.answer();
}

An unquoted import util; first checks the current package’s [dependencies] table. If it matches, the compiler reads the dependency package manifest and adds its root module to the same compile closure.

Public Surface

Cross-package access only sees the dependency package root module’s public namespace:

• public declarations in the root file are package API.
• public import in the root file re-exports a module namespace.
• public alias in the root file re-exports a public symbol. A function alias preserves the target’s public overload family and does not expose private overloads.
• public declarations in non-root files are not automatically package API.

This makes the root file the explicit API boundary of a package.

Import Boundaries

Do not use a quoted path to import dependency source across package boundaries:

import "../util/src/util.jiang"; // error: cross-package file import

Declare the dependency in package.ini, then write:

import util;

Package dependency cycles are rejected. Module import cycles are currently allowed.

Entry Function

Only the root package root module contributes the executable entry. A dependency package may define a function named main, but it is treated as an ordinary function.