Even if your script is free of XSD errors, that does not mean that the script syntax is correct. For example, there are XML elements that require at least one of multiple attributes, but this requirement cannot be reflected in a schema (apart from documentation text). Please notice the XSD documentation of the elements and attributes, e.g. displayed via tooltips in Visual Studio / Visual Web Developer. Please also note additional requirements for MD cue attributes in this guide (see NULL|Conditions).

To check for errors, please pay attention to in-game error messages that are produced while your script is imported, and run-time errors while the script runs. The XSD files can help you a lot, but you should not rely on the absence of XSD errors."

There can be a delay between the activation and performing the actions if the <delay> tag is used. In this case, sub-cues will be enter the waiting state before the parent's actions are performed.

Messages printed with <debug_text> are usually only visible when the ΓÇ£scriptsΓÇ¥ debug filter is enabled, see NULL|Script debug output.

The syntax of libraries is considerably different from the syntax in the MD of X3TC.

This sub-section requires basic knowledge of NULL|script expressions.

Since octal numbers are hardly ever used (usually unknowingly), the parser is will produce a warning if an octal number is encountered."Information

You can write string literals by putting the string in single quotes:

• 'Hello world'
• '' (empty string)
• 'String with a line break\n'

Numeric data types and suffixes

Numbers can have a suffix that determines their numeric type. There are also numerical data types like ΓÇ£moneyΓÇ¥ or ΓÇ£timeΓÇ¥ which can only be expressed by using an appropriate unit suffix:

• 5000000000L (large integer)
• 1f (floating point number, same as 1.0, just 1 would be an integer)
• 1000Cr (Money in Credits, converted to 100000 cents automatically)
• 500m (Length in metres)
• 10s (Time in seconds)
• 1h (Time in hours, which is converted to 3600s automatically)

A space between number and suffix is allowed.

Here is the complete list of numeric data types and corresponding unit suffixes:

Operators

You can build expressions by combining sub-expressions with operators. For Boolean operations, expressions are considered ΓÇ£falseΓÇ¥ if they are equal to zero, ΓÇ£trueΓÇ¥ otherwise. The following operators, delimiters, and constants are supported

Operator precedence rules

You can group sub-expressions using parentheses, but if you donΓÇÖt, the following order of operations is applied, so that 5-1+2*3 == 10 as you would expect. The order is the same as in the table above, but there are operators with the same precedence - these are applied from left to right.

• Unary operators: +, -, not, typeof, function-style operators (highest precedence)
• Power operator: ^
• Multiplicative: *, /, %
• Additive: +, -
• Comparison: lt, le, gt, ge
• Equality: ==, !=
• and
• or
• if/then/else (lowest precedence)

Type conversion

When a binary arithmetic operator is used on numbers of different types, they will be converted to a suitable output type. The resulting type depends on whether a unit data type is involved (types that are not plain integers or floats). The following cases may occur:

• Null and something else: The null value will be interpreted as ΓÇ£0ΓÇ¥ of the other type.
• Two non-unit integers: The result will be an integer of the largest involved type.
• Two non-unit numbers, not all integers: The result will be the largest involved float type.
• Non-unit and unit: The result will be the unit type.
• Two different units: The types are incompatible. This is an error, the result is undefined.

For multiplication and division, this may not be intuitive in all cases: Dividing a length by another length results in a length - so if you want to have a simple float as a result, you will have to convert it manually.

There is a way to convert a number into a different type manually: You append the corresponding suffix to a sub-expression in parentheses, like this:

• (1 + 1)f ⟹ 2f ⟹ 2.0
• (1h) m / (180deg) i ⟹ (3600s) m / (3.14rad) i ⟹ 3600m / 3 ⟹ 1200m

When converting to a non-default unit type, this means you interpret the number as in the given units: ΓÇ£(1km + 500m)hΓÇ¥ means that you interpret 1500m as 1500 hours, so the resulting value will be 1500x3600 seconds. (As stated above, the default unit for a length is metres.)

The division operation will be an integer division (rounding towards zero) if both operands are integers (see the example in the table above). So if you want to get a floating point result, you have to make sure that at least one of the operands is a floating point type.

Every data type can be combined with a string with the + operator, and will be converted to a string representation. That way you can also concatenate strings and numbers:

• 'One plus one is equal to ' + (1+1) + '.' ⟹ 'One plus one is equal to 2.'
• 'One plus one is not equal to ' + 1 + 1 + '.' ⟹ 'One plus one is not equal to 11.'

As you can see, operators of the same precedence (+ in this case) are always evaluated from left to right.

Boolean operators

Some additional notes on Boolean operators (such as and, or, not, ==):

• Of course a Boolean operation always results in true or false (integer 1 or 0).
• Values of any type can be used as Boolean operands, e.g. for ΓÇ£andΓÇ¥. They will be interpreted as ΓÇ£trueΓÇ¥ if they are non-zero or non-numeric.
• != and == can be used with any data types, even non-numeric ones. When comparing two numeric values, they are converted using the rules above. Values of non-numeric types are never equal to null, or to any other numbers.
• ΓÇ£andΓÇ¥ and ΓÇ£orΓÇ¥ use short-circuit semantics: The right side of the operation can be skipped if the left side already determines the outcome of the operation
  • Example: false and $foo ⟹ false (the value of $foo is not checked at all)
• Unlike != and ==, the comparison operators <, <=, >, >= are only supported for numeric values, difficulty levels, and attention levels. Comparing other non-numeric values will result in an error and an undefined result.
• <, <=, >, >= cannot be used in XML directly, so lt, le, gt, ge are provided as alternatives. In some cases you wonΓÇÖt have to use them, though - using range checks with additional XML attributes can be more readable.

== Strings and formatting==

==

You can concatenate string literals using the + operator, but there is also a printf-like formatting syntax, which is easier to use than concatenating lots of small pieces:

• 'The %1 %2 %3 jumps over the %5 %4'.['quick', 'brown', 'fox', 'dog', 'lazy']
• '%1 + %2 = %3'.[$a, $b, $a + $b]

See also the section about value properties.

Instead of ΓÇÿ%1 %2 %3ΓÇÖ, you can also use ΓÇÿ%s %s %sΓÇÖ, which is also compatible with Lua string formatting in the UI system. However, this should only be used if you are sure that the order is the same in all supported languages. If you want to make translators aware that they can change the order of parameters, you should prefer '%1 %2 %3'.

To get a percent character in the result string, use '%%' in the format string.



If you need a more sophisticated method for text substitution, try <substitute_text>. See the XML schema documentation for this script action.

[New as of X Rebirth 4.0]

 With the formatting syntax above, it is even possible to control how the parameter is formatted, using modifiers between "%" and the parameter specifier ("s" or the parameter number):

• '%,s'.[12345678] ⟹ '12,345,678' (the "," modifier shows a number with thousands separators, correctly localised)
• '%.3s'.[123.4] ⟹ '123.400' (show 3 fractional digits, rounding half away from zero - decimal point correctly localised)
• '%,.1s'.[12345.67]' ⟹ '12,345.7' (combination of the above)

Additional remarks:

• The "," and "." formatting modifiers only apply to numbers. They are ignored if used on values of other types.
• ┬áIf "," is used without "." then any fractional digits are discarded.
• "." must be followed by a single digit (0-9). In case of ".0" any fractional digits are discarded (rounding towards zero, not half away from zero).

Lists

Another example for a non-numeric value is a list: It is an ordered collection of other arbitrary values (called array or vector in other languages). It can be constructed within an expression using the [] syntax. It may also be generated by special actions and conditions, and there are actions that can insert or remove values.

A list can contain values of arbitrary data types, even mixed in the same list - so a list can actually contain other lists. However, some of the things that you can do with lists require that all contained elements are of a certain type. The contents of a list can be accessed via properties, see the section about value properties. Lists can be empty, these are written as ΓÇ£[ ]ΓÇ¥.

Lists are stored in variables as references, so multiple variables can refer to the same shared list: If you change a shared list through a variable, e.g. by changing the value of an element, you change it as well for all other variables. However, the operators == and != can also be used on two distinct lists to compare their elements.

Tables

Tables are associative arrays - they are like lists, but you can assign values to (almost) arbitrary keys, not just to index numbers. A table is constructed within an expression using the table[] syntax. See the section about value properties for how to access the contents of a table. Creating and removing entries works similarly to lists, but instead of inserting, you simply assign a value to a table key. If the key does not exist yet, it will be created.

Almost all values are allowed as table keys, but there are a few exceptions:

• Strings must start with '$', like variables
• null cannot be used as table key (but the number 0 is valid)
• Lists, tables, groups and buildplans cannot be used as table keys
  

These restrictions only apply to the keys, there are no restrictions for values that you assign to them. For example:

• table[] ⟹ creates an empty table
• table[{0} = null] ⟹ creates a table that maps the number 0 to null
  

• table[{'$foo'} = 'bar'] ⟹ a table that maps the string '$foo' to the string 'bar'
• table[$foo = 'bar'] ⟹ exactly the same, just a shorter notation for string keys
• table[foo = 'bar'] ⟹ error, 'foo' does not start with a '$'
• table[{1} = [], {2} = table[]]  ⟹ a table that maps 1 to an empty list and 2 to an empty table
  

Just like lists, tables are stored as references, so it's possible that multiple variables reference the same table (see above).

Value properties

Properties are a crucial concept in script expressions. In the previous sections you have seen mostly constant expressions, which are already evaluated when they are parsed at game start. For reading and writing variables and evaluating the gameΓÇÖs state, properties are used.

Numbers donΓÇÖt have any properties. Lists, for example, have quite a few of them: You can access the number of elements; and each element is also a property of the list. A ship can have properties like its name, the ship class, its position etc.

You can imagine properties as key/value pairs in an associative mapping: You pass the key, and you get the value as result. For example, the list [42, null, 'text'] has the following mapping:

• 1 ⟹ 42
• 2 ⟹ null
• 3 ⟹ 'text'
• 'count' ⟹ 3

As you can see, a property key can be a number or a string. Actually there is no restriction regarding the data type of the key.

You can look up a property by appending a dot and the key in curly braces:

• [100, 200, 300, 400].{1} ⟹ 100 (reading the first element)
• [100, 200, ['Hello ', 'world']] .{3}.{2} ⟹ 'world' (second element of the inner list, which is the third element of the outer list)
• [].{'count'} ⟹ 0
• table[{21} = 42].{21} ⟹ 42
  

In most cases the property key is a fixed string, like ΓÇ£nameΓÇ¥ or ΓÇ£classΓÇ¥. You can write this like above:

• [42].{'count'}
• $ship.{'name'}
• $ship.{'class'}
• table[$foo='bar'].{'$foo'}
  

But it is easier just to write the property key without braces, which is equivalent:

• [0].count
• $ship.name
• $ship.class
• table[$foo='bar'].$foo
  

(In this case, $ship is a variable. All variables start with a ΓÇ£$ΓÇ¥, so they cannot be confused with keywords.)

A list has even more properties:

random' returns a randomly chosen element (which requires that the list is non-empty)

min' and 'max' return the minimum or maximum (all elements have to be numeric)

• [1, 6, 8].min ⟹ 1

average' returns the average (but all element types have to be compatible)

• [1, 6, 8].average ⟹ 5

indexof' is followed by another property, and the index of the first occurence of that key in the list is returned, or 0 if itΓÇÖs not in the list

• [1, 6, 8].indexof.{8} ⟹ 3

clone' creates a shallow copy of the list (i.e. lists that are contained as elements in the list are not copied, only the reference to them)

• [1, 6, 8].clone ⟹ [1, 6, 8]

A table has different properties:

• 'clone' creates a shallow copy of the table
• 'keys' allows you to access data about the table's keys

However, 'keys' alone will not give you a result. 'keys' must be followed by another keyword to retrieve the desired information, for example:

• $table.keys.list: Yields a list of all keys in the table (reliably sorted by key if all keys are numeric)
  

• $table.keys.sorted: Yields a list of all keys in the table, sorted by their associated values (which requires that all values are numeric)
• $table.keys.random: A randomly chosen key (which requires that the table is non-empty)

=== Lookup tests and suppressing errors

===

If you look up a property that does not exist, there will be an error, and the result will be null. To test whether a property exists, you can append a question mark ΓÇ£?ΓÇ¥ to the lookup, which yields true or false:

• $list.{5} ⟹ The fifth element of a list - however, if $list has less than 5 elements (and if it's also not a table with the key 5), there will be an error
• $list.{5}? ⟹ true if $list exists and has the property 5, false otherwise
• $table.$key? ⟹ Analogously, true if $table exists and has the string property '$key'
  

The question mark can even be applied to variables:

• $list ⟹ The value stored under the name $list, or an error if there is no such variable
• $list? ⟹ true if the variable exists, false otherwise

To look up the value of a property although it may not exist, you can use the at-sign ΓÇ£@ΓÇ¥ as prefix:

• @$list.{5} ⟹ The result of the $list lookup if $list exists and has the property 5, otherwise null (without error message)
• @$list ⟹ The list if this variable exists, null otherwise
• @$list.{5}.{1} ⟹ The first element of the fifth element of $list, if it exists, null otherwise

As you can see, an error is already prevented if any link in the property chain does not exist. But use the @ prefix with care, since error messages are really helpful for detecting problems in your scripts. The @ prefix only suppresses property-related error messages and does not change any in-game behaviour.

Static lookups

There are a few data types which are basically enumerations: They only consist of a set of named values, e.g. the ΓÇ£classΓÇ¥ data type, which is used for the component classes that exist in the game. For all these static enumeration classes there is a lookup value of the same name, from which you can get the named values as properties by their name. So for the type ΓÇ£classΓÇ¥, there is a value ΓÇ£classΓÇ¥ that can be used to access the classes.

Here are a few enumeration classes and corresponding example lookup values:

Player properties

You can access many player-related game properties via the keyword ΓÇ£playerΓÇ¥:

• player.name: The playerΓÇÖs name
• player.age: The passed in-game time since game start
• player.money: The money in the playerΓÇÖs account
• player.ship: The ship the player is currently on (not necessarily the player's ship), or null if the player is on a station
  

• player.primaryship: The player's own ship (but the player is not necessarily on board)
• player.entity: The actual player object
  

• player.zone, player.sector, player.cluster, player.galaxy: Location of the player entity
• player.copilot: The co-pilot NPC

The game consists of objects of different classes (zones, ships, stations, NPCs). They have the common datatype "component", however, they have different properties, e.g. NPCs have the property "race", but ships don't.

Safe properties

Most properties cause errors if you use them on non-existing objects, such as destroyed ships. There are a few exceptions:

• exists
• isoperational
• iswreck
• isconstruction
• available
• isclass.(...)

These properties will not cause errors when used on ΓÇ£nullΓÇ¥ or on a destroyed object (which may still be accessible from scripts in some cases), and produce null or false as results, respectively. (The keyword ΓÇ£availableΓÇ¥ is used for trades, not for objects. Trades can also become invalid.) However, when using such a property on a different data type like a number, there will still be an error.

=== Money and time formatting

===

[New as of X Rebirth 4.0]

Numbers don't have any properties, except for money and time: They have a "formatted" property, which allows you to get a custom string representation with more advanced options than the generic formatting method for numbers.

• $money.formatted.{'formatstring'}
• $money.formatted.default (using default format string '%s')
  

• $time.formatted.{'formatstring'}
• $time.formatted.default (using default format string '%T')

In scripts, money is stored in cents, not Credits. The formatted representation always shows the value in Credits, including thousands separators.

When formatting the money value, any specifier (such as '%s') in the format string is replaced by the money value, so usually the format string only consists of this one specifier. The following modifiers can be used between '%' and the specifier character, to enable formatting options:

By default, these options are disabled.

More available specifiers (in addition to %s):

• %k: Credits (truncated) in kilo format
• %M: Credits (truncated) in Mega format
• %G: Credits (truncated) in Giga format
• %T: Credits (truncated) in Tera format
• %Cr: Localised "Cr" string
• %%: A % sign
  

Examples:

• (1234Cr).formatted.{'%s'}⟹'1,234'
• (1234Cr).formatted.default⟹'1,234' (same as {'%s'})
• (1234Cr).formatted.{'%.s %Cr'}⟹'1,234.00 Cr'
• (1234Cr).formatted.{'%1s'}⟹'1 k' (rounding towards zero)
• (1234Cr).formatted.{'%cM'}⟹'0 M'

For documentation of time format strings, see the Lua function ConvertTimeString() in the XRWIKIModding_supportUI_Modding_supportLua_function_overview.

Examples:

• (151s).formatted.{'%T'} ⟹ '00:02:31'
• (151s).formatted.default ⟹ '00:02:31' (same as {'%T'})
• (151s).formatted.{'%.3T'} ⟹ '00:02:31.000'
• (151s).formatted.{'%h:%M'} ⟹ '0:02'

Complete property documentation

To access the script property documentation that is included in the game, you can extract the required files from the game's catalog files using the X Catalog Tool. Extract the HTML file scriptproperties.html in the game's root folder, and all files in the "libraries" sub-folder. For resolving text references in the browser automatically, also extract 0001-L044.xml in the "t" sub-folder.

The raw documentation data is located in libraries/scriptproperties.xml, but it is recommended to open scriptproperties.html in a browser.

This provides you with a complete list of all supported ΓÇ£base keywordsΓÇ¥ and properties. To filter in this list, you can enter an expression in the text field:

• Enter the beginning of a base keyword
• Enter $ followed by the data type you are looking for (e.g. ΓÇ£$shipΓÇ¥), as if it were a variable
• To see the properties of a base keyword or data type, enter a dot (ΓÇ£.ΓÇ¥)
• After the dot, you can enter a property name
• You can also enter a dot (ΓÇ£.ΓÇ¥) as first character to search globally for a property

MD refreshing and patching

When a saved game is loaded, the saved MD state is restored, but also all MD files are reloaded and changes in them are applied to the MD state. This is called ΓÇ£refreshΓÇ¥. It is also possible to refresh the MD at run-time using the command ΓÇ£refreshmdΓÇ¥ on the in-game command line. This is a convenient way to update MD scripts while the game is already running.

Details and restrictions

Here are some noteworthy facts about refreshing scripts and cues, and the restrictions:

• MD scripts and cues are identified by their names. So a script can only be refreshed if it has the same script name as before (file name is irrelevant).
• If there are new script files or new cue nodes (i.e. scripts/cues with new names) they are created and added properly. If you remove script files or cue nodes, the corresponding scripts/cues are removed from the game, including instances.
• As a consequence, you CANNOT rename scripts or cues if you want to refresh them. Doing so would remove the old script or cue and add a new one with the new name.
• You CANNOT change a <cue> to a <library> or vice versa.
• You CANNOT add, remove, or change the "ref" attribute of a cue. But it is possible to remove the whole cue. (If all references to a library are removed you can also remove the library itself.)
• You CANNOT change the cue tree structure, i.e. if you move a cue out of its <cues> node, you also have to change its name (see above). Changing the order of cues within the same <cues> node is possible, however, the order of execution is not reliable anyway.
• You CAN change a library and change/add/remove its sub-cues. This automatically updates all cues that use the library.
• You CAN change library parameters (both in libraries and in referencing cues). However, this does not change the variables of a referencing cue if it is already enabled.
• You CAN change conditions without restrictions. You can even change between event and non-event conditions. If a cue has enabled condition checks, they are aborted and restarted (even if there is no change).
• Adding root cues enables their condition checks immediately (if the module attribute allows it).
• Adding sub-cues to active or complete cues enables their condition checks immediately.
• You CAN change/add/remove <actions>, <force>, <delay>, and all attributes without restrictions, except for the "ref" attribute (see above). You can even change the <delay> while the cue is already active and the timer is running.
• Changing instantiate="false" to "true" turns the cue into "waiting" state if it was active or complete before.
• Changing instantiate="true" to "false" removes all instantiated cues and their descendants.

Patching

Cues can have <patch> elements with actions that will be performed when an old savegame is loaded. To control which savegames should be affected, you can add a version attribute to the <cue> node and a sinceversion attribute in the patch. When a cue is loaded from a savegame that has an older version than sinceversion, the <patch> actions will be performed immediately after loading.

The patch actions are only performed if the cue is in a certain state, ΓÇ£completeΓÇ¥ by default. Use the state attribute to change this requirement. For more information, see the XML schema documentation of the <patch> element.

A sequence of multiple <patch> elements is possible. They will be performed in order of appearance, checking the sinceversion and state attributes in each case. Patches are also applied to all users of a library and to instances.

Common attribute groups

There are many commonly used actions and conditions which share groups of attributes. The most important ones are explained here.

Value comparisons

There are many conditions and conditional actions that require a value comparison, for example the condition <check_value>:

In the value attribute you specify a boolean expression, and if it is true (that is, not equal to zero), the condition is met. This is a special case: This condition and all other nodes that support a value comparison allows you to specify an upper limit, a lower limit, a number range, or a list of allowed values. Examples:

Random ranges

If an action requires a value, e.g. when you set a variable to a value, you can have some randomisation. To specify an exact value, e.g. in <set_value>, you can write this:

To select a random element from a list, this syntax can be used:

To get a random number within a given range, you can use min/max:

min and max have to be compatible number types. Enumeration types are not allowed, not even level and attention. The min attribute is optional and defaults to 0 (of the number type used in max).

You can select one of 5 different probability distribution profiles for the random range, ΓÇ£flatΓÇ¥ being the default (all values in the range are equally likely). If you select another profile, e.g. ΓÇ£increasingΓÇ¥ to make higher numbers more likely, you also have to specify a scale value (integer) that is greater or equal to 2. Higher scale values result in higher peaks in the distribution profiles (probable values become even more probable).

Variables and namespaces

As you have seen above, you can easily access variables by writing their name (including $ prefix) in an expression. Namespaces define in which cue the variables are actually stored (and from which cue they are read).

Creating and removing variables

You can create variables with certain actions and conditions, such as the <set_value> action:

<set_value> also exists as a ΓÇ£conditionΓÇ¥, which can be useful if you want to pass information about the conditions to the actions, that would otherwise be lost - like in a complex <check_any> event condition, where you want to create a variable only if you are in a certain check branch. (Other pseudo-conditions are <remove_value> and <debug_text>.)

The default operation of <set_value> is ΓÇ£setΓÇ¥, but there are more: ΓÇ£addΓÇ¥, ΓÇ£subtractΓÇ¥, and ΓÇ£insertΓÇ¥. add and subtract change the value of an existing variable, which is created as 0 if it didnΓÇÖt exist before. If neither min, max nor exact attribute is provided, an exact value of 1 is assumed.

The trick is that <set_value> not only works on variables, but also on list elements and table keys:

&lt;set_value name=&quot;$list.{1}&quot; exact=&quot;42&quot; /&gt;&lt;set_value name=&quot;$table.$foo&quot; exact=&quot;42&quot; /&gt;

The operation insert is special, and it only works on lists. It inserts the value at the specified position (note that the position beyond the last element is also valid here):

This shifts the positions of all following elements up by one. If min/max/exact are missing, the default value is null for insertions, not 1 like in other cases.

Appending is easier than that. The following actions are equivalent:

Inserting at a position below 1 or above $list.count + 1 is not possible.

To remove variables or list/table entries, use <remove_value>:

&lt;remove_value name=&quot;$foo&quot; /&gt;&lt;remove_value name=&quot;$list.{1}&quot; /&gt;&lt;remove_value name=&quot;$table.$foo&quot; /&gt;

Removing an entry from a list shifts all following elements down by one. If you want to clear an entry without removing it from the list, just use <set_value> instead.

Accessing remote variables

You can also read and write variables in other cues by using the variable name as property key:

Instead of referencing a cue by name, you could also reference it via a keyword or another variable:

Namespaces

In the examples above, a variable was written to and read from the ΓÇ£thisΓÇ¥ cue. This can be necessary: the expression ΓÇ£$fooΓÇ¥ may be different from the expression ΓÇ£this.$fooΓÇ¥. The reason for that are namespaces.

Consider this case:

When the root cue creates $foo, the variable is stored in the Root cue directly. But SubCue and its descendants will also need access to $foo. Of course they could write ΓÇ£parent.$fooΓÇ¥ or ΓÇ£Root.$fooΓÇ¥, but since itΓÇÖs very common to have a single location for most variables in the whole cue tree, the easy solution is to write just ΓÇ£$fooΓÇ¥ - because variable names are looked up in the namespace cue, which is the root by default. Also newly created variables end up in the namespace, and not in ΓÇ£thisΓÇ¥ cue.

You can also use the keyword ΓÇ£namespaceΓÇ¥ in expressions to get the namespace cue.

Defining a cueΓÇÖs namespace

When writing a cue, you can specify what the namespace of the cue should be, by adding the namespace attribute. The following values are possible:

• this: Use ΓÇ£thisΓÇ¥ cue as namespace, even for instances: $foo == this.$foo
• static: Same as ΓÇ£thisΓÇ¥, but when instantiated, use the static cue: $foo == static.$foo
• default: The namespace is inherited from the parent cue. The default for root cues and for libraries is the same as ΓÇ£staticΓÇ¥.